GCC Code Coverage Report

Directory: ./
File: Python/compile.c
Date: 2022-06-27 09:02:04
Exec Total Coverage
Lines: 3747 4974 75.3%
Functions: 217 237 91.6%
Branches: 2698 4517 59.7%
Line Branch Exec Source
1 /*
2 * This file compiles an abstract syntax tree (AST) into Python bytecode.
3 *
4 * The primary entry point is _PyAST_Compile(), which returns a
5 * PyCodeObject. The compiler makes several passes to build the code
6 * object:
7 * 1. Checks for future statements. See future.c
8 * 2. Builds a symbol table. See symtable.c.
9 * 3. Generate code for basic blocks. See compiler_mod() in this file.
10 * 4. Assemble the basic blocks into final code. See assemble() in
11 * this file.
12 * 5. Optimize the byte code (peephole optimizations).
13 *
14 * Note that compiler_mod() suggests module, but the module ast type
15 * (mod_ty) has cases for expressions and interactive statements.
16 *
17 * CAUTION: The VISIT_* macros abort the current function when they
18 * encounter a problem. So don't invoke them when there is memory
19 * which needs to be released. Code blocks are OK, as the compiler
20 * structure takes care of releasing those. Use the arena to manage
21 * objects.
22 */
23
24 #include <stdbool.h>
25
26 // Need _PyOpcode_RelativeJump of pycore_opcode.h
27 #define NEED_OPCODE_TABLES
28
29 #include "Python.h"
30 #include "pycore_ast.h" // _PyAST_GetDocString()
31 #include "pycore_code.h" // _PyCode_New()
32 #include "pycore_compile.h" // _PyFuture_FromAST()
33 #include "pycore_long.h" // _PyLong_GetZero()
34 #include "pycore_opcode.h" // _PyOpcode_Caches
35 #include "pycore_pymem.h" // _PyMem_IsPtrFreed()
36 #include "pycore_symtable.h" // PySTEntryObject
37
38
39 #define DEFAULT_BLOCK_SIZE 16
40 #define DEFAULT_CODE_SIZE 128
41 #define DEFAULT_LNOTAB_SIZE 16
42 #define DEFAULT_CNOTAB_SIZE 32
43
44 #define COMP_GENEXP 0
45 #define COMP_LISTCOMP 1
46 #define COMP_SETCOMP 2
47 #define COMP_DICTCOMP 3
48
49 /* A soft limit for stack use, to avoid excessive
50 * memory use for large constants, etc.
51 *
52 * The value 30 is plucked out of thin air.
53 * Code that could use more stack than this is
54 * rare, so the exact value is unimportant.
55 */
56 #define STACK_USE_GUIDELINE 30
57
58 /* If we exceed this limit, it should
59 * be considered a compiler bug.
60 * Currently it should be impossible
61 * to exceed STACK_USE_GUIDELINE * 100,
62 * as 100 is the maximum parse depth.
63 * For performance reasons we will
64 * want to reduce this to a
65 * few hundred in the future.
66 *
67 * NOTE: Whatever MAX_ALLOWED_STACK_USE is
68 * set to, it should never restrict what Python
69 * we can write, just how we compile it.
70 */
71 #define MAX_ALLOWED_STACK_USE (STACK_USE_GUIDELINE * 100)
72
73
74 /* Pseudo-instructions used in the compiler,
75 * but turned into NOPs or other instructions
76 * by the assembler. */
77 #define SETUP_FINALLY -1
78 #define SETUP_CLEANUP -2
79 #define SETUP_WITH -3
80 #define POP_BLOCK -4
81 #define JUMP -5
82 #define JUMP_NO_INTERRUPT -6
83 #define POP_JUMP_IF_FALSE -7
84 #define POP_JUMP_IF_TRUE -8
85 #define POP_JUMP_IF_NONE -9
86 #define POP_JUMP_IF_NOT_NONE -10
87 #define LOAD_METHOD -11
88
89 #define MIN_VIRTUAL_OPCODE -11
90 #define MAX_ALLOWED_OPCODE 254
91
92 #define IS_WITHIN_OPCODE_RANGE(opcode) \
93 ((opcode) >= MIN_VIRTUAL_OPCODE && (opcode) <= MAX_ALLOWED_OPCODE)
94
95 #define IS_VIRTUAL_OPCODE(opcode) ((opcode) < 0)
96
97 #define IS_VIRTUAL_JUMP_OPCODE(opcode) \
98 ((opcode) == JUMP || \
99 (opcode) == JUMP_NO_INTERRUPT || \
100 (opcode) == POP_JUMP_IF_NONE || \
101 (opcode) == POP_JUMP_IF_NOT_NONE || \
102 (opcode) == POP_JUMP_IF_FALSE || \
103 (opcode) == POP_JUMP_IF_TRUE)
104
105 #define IS_JUMP_OPCODE(opcode) \
106 (IS_VIRTUAL_JUMP_OPCODE(opcode) || \
107 is_bit_set_in_table(_PyOpcode_Jump, opcode))
108
109 #define IS_BLOCK_PUSH_OPCODE(opcode) \
110 ((opcode) == SETUP_FINALLY || \
111 (opcode) == SETUP_WITH || \
112 (opcode) == SETUP_CLEANUP)
113
114 /* opcodes which are not emitted in codegen stage, only by the assembler */
115 #define IS_ASSEMBLER_OPCODE(opcode) \
116 ((opcode) == JUMP_FORWARD || \
117 (opcode) == JUMP_BACKWARD || \
118 (opcode) == JUMP_BACKWARD_NO_INTERRUPT || \
119 (opcode) == POP_JUMP_FORWARD_IF_NONE || \
120 (opcode) == POP_JUMP_BACKWARD_IF_NONE || \
121 (opcode) == POP_JUMP_FORWARD_IF_NOT_NONE || \
122 (opcode) == POP_JUMP_BACKWARD_IF_NOT_NONE || \
123 (opcode) == POP_JUMP_FORWARD_IF_TRUE || \
124 (opcode) == POP_JUMP_BACKWARD_IF_TRUE || \
125 (opcode) == POP_JUMP_FORWARD_IF_FALSE || \
126 (opcode) == POP_JUMP_BACKWARD_IF_FALSE)
127
128
129 #define IS_BACKWARDS_JUMP_OPCODE(opcode) \
130 ((opcode) == JUMP_BACKWARD || \
131 (opcode) == JUMP_BACKWARD_NO_INTERRUPT || \
132 (opcode) == POP_JUMP_BACKWARD_IF_NONE || \
133 (opcode) == POP_JUMP_BACKWARD_IF_NOT_NONE || \
134 (opcode) == POP_JUMP_BACKWARD_IF_TRUE || \
135 (opcode) == POP_JUMP_BACKWARD_IF_FALSE)
136
137 #define IS_UNCONDITIONAL_JUMP_OPCODE(opcode) \
138 ((opcode) == JUMP || \
139 (opcode) == JUMP_NO_INTERRUPT || \
140 (opcode) == JUMP_FORWARD || \
141 (opcode) == JUMP_BACKWARD || \
142 (opcode) == JUMP_BACKWARD_NO_INTERRUPT)
143
144 #define IS_SCOPE_EXIT_OPCODE(opcode) \
145 ((opcode) == RETURN_VALUE || \
146 (opcode) == RAISE_VARARGS || \
147 (opcode) == RERAISE)
148
149 #define IS_TOP_LEVEL_AWAIT(c) ( \
150 (c->c_flags->cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \
151 && (c->u->u_ste->ste_type == ModuleBlock))
152
153 struct location {
154 int lineno;
155 int end_lineno;
156 int col_offset;
157 int end_col_offset;
158 };
159
160 #define LOCATION(LNO, END_LNO, COL, END_COL) \
161 ((const struct location){(LNO), (END_LNO), (COL), (END_COL)})
162
163 static struct location NO_LOCATION = {-1, -1, -1, -1};
164
165 struct instr {
166 int i_opcode;
167 int i_oparg;
168 /* target block (if jump instruction) */
169 struct basicblock_ *i_target;
170 /* target block when exception is raised, should not be set by front-end. */
171 struct basicblock_ *i_except;
172 struct location i_loc;
173 };
174
175 typedef struct exceptstack {
176 struct basicblock_ *handlers[CO_MAXBLOCKS+1];
177 int depth;
178 } ExceptStack;
179
180 #define LOG_BITS_PER_INT 5
181 #define MASK_LOW_LOG_BITS 31
182
183 static inline int
184 134100507 is_bit_set_in_table(const uint32_t *table, int bitindex) {
185 /* Is the relevant bit set in the relevant word? */
186 /* 256 bits fit into 8 32-bits words.
187 * Word is indexed by (bitindex>>ln(size of int in bits)).
188 * Bit within word is the low bits of bitindex.
189 */
190
3/4
✓ Branch 0 taken 133624043 times.
✓ Branch 1 taken 476464 times.
✓ Branch 2 taken 133624043 times.
✗ Branch 3 not taken.
 134100507 if (bitindex >= 0 && bitindex < 256) {
191 133624043 uint32_t word = table[bitindex >> LOG_BITS_PER_INT];
192 133624043 return (word >> (bitindex & MASK_LOW_LOG_BITS)) & 1;
193 }
194 else {
195 476464 return 0;
196 }
197 }
198
199 static inline int
200 508695 is_relative_jump(struct instr *i)
201 {
202 508695 return is_bit_set_in_table(_PyOpcode_RelativeJump, i->i_opcode);
203 }
204
205 static inline int
206 88285653 is_block_push(struct instr *i)
207 {
208
6/6
✓ Branch 0 taken 88192107 times.
✓ Branch 1 taken 93546 times.
✓ Branch 2 taken 88161579 times.
✓ Branch 3 taken 30528 times.
✓ Branch 4 taken 138263 times.
✓ Branch 5 taken 88023316 times.
 88285653 return IS_BLOCK_PUSH_OPCODE(i->i_opcode);
209 }
210
211 static inline int
212 121994942 is_jump(struct instr *i)
213 {
214
14/14
✓ Branch 0 taken 121096541 times.
✓ Branch 1 taken 898401 times.
✓ Branch 2 taken 121081481 times.
✓ Branch 3 taken 15060 times.
✓ Branch 4 taken 120974501 times.
✓ Branch 5 taken 106980 times.
✓ Branch 6 taken 120895618 times.
✓ Branch 7 taken 78883 times.
✓ Branch 8 taken 119393103 times.
✓ Branch 9 taken 1502515 times.
✓ Branch 10 taken 118332792 times.
✓ Branch 11 taken 1060311 times.
✓ Branch 13 taken 2263369 times.
✓ Branch 14 taken 116069423 times.
 121994942 return IS_JUMP_OPCODE(i->i_opcode);
215 }
216
217 static int
218 78780079 instr_size(struct instr *instruction)
219 {
220 78780079 int opcode = instruction->i_opcode;
221 assert(!IS_VIRTUAL_OPCODE(opcode));
222
2/2
✓ Branch 0 taken 71661025 times.
✓ Branch 1 taken 7119054 times.
 78780079 int oparg = HAS_ARG(opcode) ? instruction->i_oparg : 0;
223 78780079 int extended_args = (0xFFFFFF < oparg) + (0xFFFF < oparg) + (0xFF < oparg);
224 78780079 int caches = _PyOpcode_Caches[opcode];
225 78780079 return extended_args + 1 + caches;
226 }
227
228 static void
229 14497150 write_instr(_Py_CODEUNIT *codestr, struct instr *instruction, int ilen)
230 {
231 14497150 int opcode = instruction->i_opcode;
232 assert(!IS_VIRTUAL_OPCODE(opcode));
233
2/2
✓ Branch 0 taken 13160338 times.
✓ Branch 1 taken 1336812 times.
 14497150 int oparg = HAS_ARG(opcode) ? instruction->i_oparg : 0;
234 14497150 int caches = _PyOpcode_Caches[opcode];
235
2/5
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✓ Branch 2 taken 332707 times.
✓ Branch 3 taken 14164443 times.
✗ Branch 4 not taken.
 14497150 switch (ilen - caches) {
236 ✗ case 4:
237 ✗ *codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG_QUICK, (oparg >> 24) & 0xFF);
238 /* fall through */
239 ✗ case 3:
240 ✗ *codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG_QUICK, (oparg >> 16) & 0xFF);
241 /* fall through */
242 332707 case 2:
243 332707 *codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG_QUICK, (oparg >> 8) & 0xFF);
244 /* fall through */
245 14497150 case 1:
246 14497150 *codestr++ = _Py_MAKECODEUNIT(opcode, oparg & 0xFF);
247 14497150 break;
248 ✗ default:
249 ✗ Py_UNREACHABLE();
250 }
251
2/2
✓ Branch 0 taken 23124517 times.
✓ Branch 1 taken 14497150 times.
 37621667 while (caches--) {
252 23124517 *codestr++ = _Py_MAKECODEUNIT(CACHE, 0);
253 }
254 14497150 }
255
256 typedef struct basicblock_ {
257 /* Each basicblock in a compilation unit is linked via b_list in the
258 reverse order that the block are allocated. b_list points to the next
259 block, not to be confused with b_next, which is next by control flow. */
260 struct basicblock_ *b_list;
261 /* Exception stack at start of block, used by assembler to create the exception handling table */
262 ExceptStack *b_exceptstack;
263 /* pointer to an array of instructions, initially NULL */
264 struct instr *b_instr;
265 /* If b_next is non-NULL, it is a pointer to the next
266 block reached by normal control flow. */
267 struct basicblock_ *b_next;
268 /* number of instructions used */
269 int b_iused;
270 /* length of instruction array (b_instr) */
271 int b_ialloc;
272 /* Number of predecssors that a block has. */
273 int b_predecessors;
274 /* Number of predecssors that a block has as an exception handler. */
275 int b_except_predecessors;
276 /* depth of stack upon entry of block, computed by stackdepth() */
277 int b_startdepth;
278 /* instruction offset for block, computed by assemble_jump_offsets() */
279 int b_offset;
280 /* Basic block is an exception handler that preserves lasti */
281 unsigned b_preserve_lasti : 1;
282 /* Used by compiler passes to mark whether they have visited a basic block. */
283 unsigned b_visited : 1;
284 /* b_cold is true if this block is not perf critical (like an exception handler) */
285 unsigned b_cold : 1;
286 /* b_warm is used by the cold-detection algorithm to mark blocks which are definitely not cold */
287 unsigned b_warm : 1;
288 } basicblock;
289
290
291 static struct instr *
292 24201404 basicblock_last_instr(basicblock *b) {
293
2/2
✓ Branch 0 taken 24143499 times.
✓ Branch 1 taken 57905 times.
 24201404 if (b->b_iused) {
294 24143499 return &b->b_instr[b->b_iused - 1];
295 }
296 57905 return NULL;
297 }
298
299 static inline int
300 448800 basicblock_returns(basicblock *b) {
301 448800 struct instr *last = basicblock_last_instr(b);
302
4/4
✓ Branch 0 taken 408012 times.
✓ Branch 1 taken 40788 times.
✓ Branch 2 taken 224990 times.
✓ Branch 3 taken 183022 times.
 448800 return last && last->i_opcode == RETURN_VALUE;
303 }
304
305 static inline int
306 1200809 basicblock_exits_scope(basicblock *b) {
307 1200809 struct instr *last = basicblock_last_instr(b);
308
8/8
✓ Branch 0 taken 1200785 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 960168 times.
✓ Branch 3 taken 240617 times.
✓ Branch 4 taken 856838 times.
✓ Branch 5 taken 103330 times.
✓ Branch 6 taken 16260 times.
✓ Branch 7 taken 840578 times.
 1200809 return last && IS_SCOPE_EXIT_OPCODE(last->i_opcode);
309 }
310
311 static inline int
312 7872445 basicblock_nofallthrough(basicblock *b) {
313 7872445 struct instr *last = basicblock_last_instr(b);
314
2/2
✓ Branch 0 taken 7855352 times.
✓ Branch 1 taken 17093 times.
 15727797 return (last &&
315
6/6
✓ Branch 0 taken 6017022 times.
✓ Branch 1 taken 1838330 times.
✓ Branch 2 taken 5350055 times.
✓ Branch 3 taken 666967 times.
✓ Branch 4 taken 5054794 times.
✓ Branch 5 taken 295261 times.
 7855352 (IS_SCOPE_EXIT_OPCODE(last->i_opcode) ||
316
10/10
✓ Branch 0 taken 4541833 times.
✓ Branch 1 taken 512961 times.
✓ Branch 2 taken 4533494 times.
✓ Branch 3 taken 8339 times.
✓ Branch 4 taken 4444669 times.
✓ Branch 5 taken 88825 times.
✓ Branch 6 taken 4316357 times.
✓ Branch 7 taken 128312 times.
✓ Branch 8 taken 1588 times.
✓ Branch 9 taken 4314769 times.
 5054794 IS_UNCONDITIONAL_JUMP_OPCODE(last->i_opcode)));
317 }
318
319 #define BB_NO_FALLTHROUGH(B) (basicblock_nofallthrough(B))
320 #define BB_HAS_FALLTHROUGH(B) (!basicblock_nofallthrough(B))
321
322 /* fblockinfo tracks the current frame block.
323
324 A frame block is used to handle loops, try/except, and try/finally.
325 It's called a frame block to distinguish it from a basic block in the
326 compiler IR.
327 */
328
329 enum fblocktype { WHILE_LOOP, FOR_LOOP, TRY_EXCEPT, FINALLY_TRY, FINALLY_END,
330 WITH, ASYNC_WITH, HANDLER_CLEANUP, POP_VALUE, EXCEPTION_HANDLER,
331 EXCEPTION_GROUP_HANDLER, ASYNC_COMPREHENSION_GENERATOR };
332
333 struct fblockinfo {
334 enum fblocktype fb_type;
335 basicblock *fb_block;
336 /* (optional) type-specific exit or cleanup block */
337 basicblock *fb_exit;
338 /* (optional) additional information required for unwinding */
339 void *fb_datum;
340 };
341
342 enum {
343 COMPILER_SCOPE_MODULE,
344 COMPILER_SCOPE_CLASS,
345 COMPILER_SCOPE_FUNCTION,
346 COMPILER_SCOPE_ASYNC_FUNCTION,
347 COMPILER_SCOPE_LAMBDA,
348 COMPILER_SCOPE_COMPREHENSION,
349 };
350
351 /* The following items change on entry and exit of code blocks.
352 They must be saved and restored when returning to a block.
353 */
354 struct compiler_unit {
355 PySTEntryObject *u_ste;
356
357 PyObject *u_name;
358 PyObject *u_qualname; /* dot-separated qualified name (lazy) */
359 int u_scope_type;
360
361 /* The following fields are dicts that map objects to
362 the index of them in co_XXX. The index is used as
363 the argument for opcodes that refer to those collections.
364 */
365 PyObject *u_consts; /* all constants */
366 PyObject *u_names; /* all names */
367 PyObject *u_varnames; /* local variables */
368 PyObject *u_cellvars; /* cell variables */
369 PyObject *u_freevars; /* free variables */
370
371 PyObject *u_private; /* for private name mangling */
372
373 Py_ssize_t u_argcount; /* number of arguments for block */
374 Py_ssize_t u_posonlyargcount; /* number of positional only arguments for block */
375 Py_ssize_t u_kwonlyargcount; /* number of keyword only arguments for block */
376 /* Pointer to the most recently allocated block. By following b_list
377 members, you can reach all early allocated blocks. */
378 basicblock *u_blocks;
379 basicblock *u_curblock; /* pointer to current block */
380
381 int u_nfblocks;
382 struct fblockinfo u_fblock[CO_MAXBLOCKS];
383
384 int u_firstlineno; /* the first lineno of the block */
385 struct location u_loc; /* line/column info of the current stmt */
386 };
387
388 /* This struct captures the global state of a compilation.
389
390 The u pointer points to the current compilation unit, while units
391 for enclosing blocks are stored in c_stack. The u and c_stack are
392 managed by compiler_enter_scope() and compiler_exit_scope().
393
394 Note that we don't track recursion levels during compilation - the
395 task of detecting and rejecting excessive levels of nesting is
396 handled by the symbol analysis pass.
397
398 */
399
400 struct compiler {
401 PyObject *c_filename;
402 struct symtable *c_st;
403 PyFutureFeatures *c_future; /* pointer to module's __future__ */
404 PyCompilerFlags *c_flags;
405
406 int c_optimize; /* optimization level */
407 int c_interactive; /* true if in interactive mode */
408 int c_nestlevel;
409 PyObject *c_const_cache; /* Python dict holding all constants,
410 including names tuple */
411 struct compiler_unit *u; /* compiler state for current block */
412 PyObject *c_stack; /* Python list holding compiler_unit ptrs */
413 PyArena *c_arena; /* pointer to memory allocation arena */
414 };
415
416 typedef struct {
417 // A list of strings corresponding to name captures. It is used to track:
418 // - Repeated name assignments in the same pattern.
419 // - Different name assignments in alternatives.
420 // - The order of name assignments in alternatives.
421 PyObject *stores;
422 // If 0, any name captures against our subject will raise.
423 int allow_irrefutable;
424 // An array of blocks to jump to on failure. Jumping to fail_pop[i] will pop
425 // i items off of the stack. The end result looks like this (with each block
426 // falling through to the next):
427 // fail_pop[4]: POP_TOP
428 // fail_pop[3]: POP_TOP
429 // fail_pop[2]: POP_TOP
430 // fail_pop[1]: POP_TOP
431 // fail_pop[0]: NOP
432 basicblock **fail_pop;
433 // The current length of fail_pop.
434 Py_ssize_t fail_pop_size;
435 // The number of items on top of the stack that need to *stay* on top of the
436 // stack. Variable captures go beneath these. All of them will be popped on
437 // failure.
438 Py_ssize_t on_top;
439 } pattern_context;
440
441 static int basicblock_next_instr(basicblock *);
442
443 static int compiler_enter_scope(struct compiler *, identifier, int, void *, int);
444 static void compiler_free(struct compiler *);
445 static basicblock *compiler_new_block(struct compiler *);
446 static int compiler_addop(struct compiler *, int, bool);
447 static int compiler_addop_i(struct compiler *, int, Py_ssize_t, bool);
448 static int compiler_addop_j(struct compiler *, int, basicblock *, bool);
449 static int compiler_error(struct compiler *, const char *, ...);
450 static int compiler_warn(struct compiler *, const char *, ...);
451 static int compiler_nameop(struct compiler *, identifier, expr_context_ty);
452
453 static PyCodeObject *compiler_mod(struct compiler *, mod_ty);
454 static int compiler_visit_stmt(struct compiler *, stmt_ty);
455 static int compiler_visit_keyword(struct compiler *, keyword_ty);
456 static int compiler_visit_expr(struct compiler *, expr_ty);
457 static int compiler_augassign(struct compiler *, stmt_ty);
458 static int compiler_annassign(struct compiler *, stmt_ty);
459 static int compiler_subscript(struct compiler *, expr_ty);
460 static int compiler_slice(struct compiler *, expr_ty);
461
462 static int are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t);
463
464
465 static int compiler_with(struct compiler *, stmt_ty, int);
466 static int compiler_async_with(struct compiler *, stmt_ty, int);
467 static int compiler_async_for(struct compiler *, stmt_ty);
468 static int validate_keywords(struct compiler *c, asdl_keyword_seq *keywords);
469 static int compiler_call_simple_kw_helper(struct compiler *c,
470 asdl_keyword_seq *keywords,
471 Py_ssize_t nkwelts);
472 static int compiler_call_helper(struct compiler *c, int n,
473 asdl_expr_seq *args,
474 asdl_keyword_seq *keywords);
475 static int compiler_try_except(struct compiler *, stmt_ty);
476 static int compiler_try_star_except(struct compiler *, stmt_ty);
477 static int compiler_set_qualname(struct compiler *);
478
479 static int compiler_sync_comprehension_generator(
480 struct compiler *c,
481 asdl_comprehension_seq *generators, int gen_index,
482 int depth,
483 expr_ty elt, expr_ty val, int type);
484
485 static int compiler_async_comprehension_generator(
486 struct compiler *c,
487 asdl_comprehension_seq *generators, int gen_index,
488 int depth,
489 expr_ty elt, expr_ty val, int type);
490
491 static int compiler_pattern(struct compiler *, pattern_ty, pattern_context *);
492 static int compiler_match(struct compiler *, stmt_ty);
493 static int compiler_pattern_subpattern(struct compiler *, pattern_ty,
494 pattern_context *);
495
496 static void clean_basic_block(basicblock *bb);
497
498 static PyCodeObject *assemble(struct compiler *, int addNone);
499
500 #define CAPSULE_NAME "compile.c compiler unit"
501
502 PyObject *
503 12540737 _Py_Mangle(PyObject *privateobj, PyObject *ident)
504 {
505 /* Name mangling: __private becomes _classname__private.
506 This is independent from how the name is used. */
507 PyObject *result;
508 size_t nlen, plen, ipriv;
509 Py_UCS4 maxchar;
510
5/6
✓ Branch 0 taken 3129159 times.
✓ Branch 1 taken 9411578 times.
✓ Branch 4 taken 3129159 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 388044 times.
✓ Branch 7 taken 2741115 times.
 15669896 if (privateobj == NULL || !PyUnicode_Check(privateobj) ||
511
2/2
✓ Branch 1 taken 255885 times.
✓ Branch 2 taken 132159 times.
 3517203 PyUnicode_READ_CHAR(ident, 0) != '_' ||
512 388044 PyUnicode_READ_CHAR(ident, 1) != '_') {
513 12408578 Py_INCREF(ident);
514 12408578 return ident;
515 }
516 132159 nlen = PyUnicode_GET_LENGTH(ident);
517 132159 plen = PyUnicode_GET_LENGTH(privateobj);
518 /* Don't mangle __id__ or names with dots.
519
520 The only time a name with a dot can occur is when
521 we are compiling an import statement that has a
522 package name.
523
524 TODO(jhylton): Decide whether we want to support
525 mangling of the module name, e.g. __M.X.
526 */
527
4/4
✓ Branch 1 taken 130324 times.
✓ Branch 2 taken 1835 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 130321 times.
 262483 if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&
528
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1838 times.
 132162 PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||
529 1838 PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {
530 130321 Py_INCREF(ident);
531 130321 return ident; /* Don't mangle __whatever__ */
532 }
533 /* Strip leading underscores from class name */
534 1838 ipriv = 0;
535
2/2
✓ Branch 1 taken 491 times.
✓ Branch 2 taken 1838 times.
 2329 while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_')
536 491 ipriv++;
537
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1838 times.
 1838 if (ipriv == plen) {
538 ✗ Py_INCREF(ident);
539 ✗ return ident; /* Don't mangle if class is just underscores */
540 }
541 1838 plen -= ipriv;
542
543
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1838 times.
 1838 if (plen + nlen >= PY_SSIZE_T_MAX - 1) {
544 ✗ PyErr_SetString(PyExc_OverflowError,
545 "private identifier too large to be mangled");
546 ✗ return NULL;
547 }
548
549 1838 maxchar = PyUnicode_MAX_CHAR_VALUE(ident);
550
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1838 times.
 1838 if (PyUnicode_MAX_CHAR_VALUE(privateobj) > maxchar)
551 ✗ maxchar = PyUnicode_MAX_CHAR_VALUE(privateobj);
552
553 1838 result = PyUnicode_New(1 + nlen + plen, maxchar);
554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1838 times.
 1838 if (!result)
555 ✗ return 0;
556 /* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */
557 1838 PyUnicode_WRITE(PyUnicode_KIND(result), PyUnicode_DATA(result), 0, '_');
558
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1838 times.
 1838 if (PyUnicode_CopyCharacters(result, 1, privateobj, ipriv, plen) < 0) {
559 ✗ Py_DECREF(result);
560 ✗ return NULL;
561 }
562
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1838 times.
 1838 if (PyUnicode_CopyCharacters(result, plen+1, ident, 0, nlen) < 0) {
563 ✗ Py_DECREF(result);
564 ✗ return NULL;
565 }
566 assert(_PyUnicode_CheckConsistency(result, 1));
567 1838 return result;
568 }
569
570 static int
571 156685 compiler_init(struct compiler *c)
572 {
573 156685 memset(c, 0, sizeof(struct compiler));
574
575 156685 c->c_const_cache = PyDict_New();
576
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 156685 times.
 156685 if (!c->c_const_cache) {
577 ✗ return 0;
578 }
579
580 156685 c->c_stack = PyList_New(0);
581
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 156685 times.
 156685 if (!c->c_stack) {
582 ✗ Py_CLEAR(c->c_const_cache);
583 ✗ return 0;
584 }
585
586 156685 return 1;
587 }
588
589 PyCodeObject *
590 156685 _PyAST_Compile(mod_ty mod, PyObject *filename, PyCompilerFlags *flags,
591 int optimize, PyArena *arena)
592 {
593 struct compiler c;
594 156685 PyCodeObject *co = NULL;
595 156685 PyCompilerFlags local_flags = _PyCompilerFlags_INIT;
596 int merged;
597
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 156685 times.
 156685 if (!compiler_init(&c))
598 ✗ return NULL;
599 156685 Py_INCREF(filename);
600 156685 c.c_filename = filename;
601 156685 c.c_arena = arena;
602 156685 c.c_future = _PyFuture_FromAST(mod, filename);
603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 156685 times.
 156685 if (c.c_future == NULL)
604 ✗ goto finally;
605
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 156681 times.
 156685 if (!flags) {
606 4 flags = &local_flags;
607 }
608 156685 merged = c.c_future->ff_features | flags->cf_flags;
609 156685 c.c_future->ff_features = merged;
610 156685 flags->cf_flags = merged;
611 156685 c.c_flags = flags;
612
2/2
✓ Branch 0 taken 156661 times.
✓ Branch 1 taken 24 times.
 156685 c.c_optimize = (optimize == -1) ? _Py_GetConfig()->optimization_level : optimize;
613 156685 c.c_nestlevel = 0;
614
615 _PyASTOptimizeState state;
616 156685 state.optimize = c.c_optimize;
617 156685 state.ff_features = merged;
618
619
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 156685 times.
 156685 if (!_PyAST_Optimize(mod, arena, &state)) {
620 ✗ goto finally;
621 }
622
623 156685 c.c_st = _PySymtable_Build(mod, filename, c.c_future);
624
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 156685 times.
 156685 if (c.c_st == NULL) {
625 ✗ if (!PyErr_Occurred())
626 ✗ PyErr_SetString(PyExc_SystemError, "no symtable");
627 ✗ goto finally;
628 }
629
630 156685 co = compiler_mod(&c, mod);
631
632 156685 finally:
633 156685 compiler_free(&c);
634 assert(co || PyErr_Occurred());
635 156685 return co;
636 }
637
638 static void
639 156685 compiler_free(struct compiler *c)
640 {
641
1/2
✓ Branch 0 taken 156685 times.
✗ Branch 1 not taken.
 156685 if (c->c_st)
642 156685 _PySymtable_Free(c->c_st);
643
1/2
✓ Branch 0 taken 156685 times.
✗ Branch 1 not taken.
 156685 if (c->c_future)
644 156685 PyObject_Free(c->c_future);
645 156685 Py_XDECREF(c->c_filename);
646 156685 Py_DECREF(c->c_const_cache);
647 156685 Py_DECREF(c->c_stack);
648 156685 }
649
650 static PyObject *
651 448800 list2dict(PyObject *list)
652 {
653 Py_ssize_t i, n;
654 PyObject *v, *k;
655 448800 PyObject *dict = PyDict_New();
656
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!dict) return NULL;
657
658 448800 n = PyList_Size(list);
659
2/2
✓ Branch 0 taken 973930 times.
✓ Branch 1 taken 448800 times.
 1422730 for (i = 0; i < n; i++) {
660 973930 v = PyLong_FromSsize_t(i);
661
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 973930 times.
 973930 if (!v) {
662 ✗ Py_DECREF(dict);
663 ✗ return NULL;
664 }
665 973930 k = PyList_GET_ITEM(list, i);
666
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 973930 times.
 973930 if (PyDict_SetItem(dict, k, v) < 0) {
667 ✗ Py_DECREF(v);
668 ✗ Py_DECREF(dict);
669 ✗ return NULL;
670 }
671 973930 Py_DECREF(v);
672 }
673 448800 return dict;
674 }
675
676 /* Return new dict containing names from src that match scope(s).
677
678 src is a symbol table dictionary. If the scope of a name matches
679 either scope_type or flag is set, insert it into the new dict. The
680 values are integers, starting at offset and increasing by one for
681 each key.
682 */
683
684 static PyObject *
685 897600 dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset)
686 {
687 897600 Py_ssize_t i = offset, scope, num_keys, key_i;
688 897600 PyObject *k, *v, *dest = PyDict_New();
689 PyObject *sorted_keys;
690
691 assert(offset >= 0);
692
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 897600 times.
 897600 if (dest == NULL)
693 ✗ return NULL;
694
695 /* Sort the keys so that we have a deterministic order on the indexes
696 saved in the returned dictionary. These indexes are used as indexes
697 into the free and cell var storage. Therefore if they aren't
698 deterministic, then the generated bytecode is not deterministic.
699 */
700 897600 sorted_keys = PyDict_Keys(src);
701
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 897600 times.
 897600 if (sorted_keys == NULL)
702 ✗ return NULL;
703
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 897600 times.
 897600 if (PyList_Sort(sorted_keys) != 0) {
704 ✗ Py_DECREF(sorted_keys);
705 ✗ return NULL;
706 }
707 897600 num_keys = PyList_GET_SIZE(sorted_keys);
708
709
2/2
✓ Branch 0 taken 4296772 times.
✓ Branch 1 taken 897600 times.
 5194372 for (key_i = 0; key_i < num_keys; key_i++) {
710 /* XXX this should probably be a macro in symtable.h */
711 long vi;
712 4296772 k = PyList_GET_ITEM(sorted_keys, key_i);
713 4296772 v = PyDict_GetItemWithError(src, k);
714 assert(v && PyLong_Check(v));
715 4296772 vi = PyLong_AS_LONG(v);
716 4296772 scope = (vi >> SCOPE_OFFSET) & SCOPE_MASK;
717
718
4/4
✓ Branch 0 taken 4251511 times.
✓ Branch 1 taken 45261 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 4251505 times.
 4296772 if (scope == scope_type || vi & flag) {
719 45267 PyObject *item = PyLong_FromSsize_t(i);
720
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45267 times.
 45267 if (item == NULL) {
721 ✗ Py_DECREF(sorted_keys);
722 ✗ Py_DECREF(dest);
723 ✗ return NULL;
724 }
725 45267 i++;
726
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 45267 times.
 45267 if (PyDict_SetItem(dest, k, item) < 0) {
727 ✗ Py_DECREF(sorted_keys);
728 ✗ Py_DECREF(item);
729 ✗ Py_DECREF(dest);
730 ✗ return NULL;
731 }
732 45267 Py_DECREF(item);
733 }
734 }
735 897600 Py_DECREF(sorted_keys);
736 897600 return dest;
737 }
738
739 static void
740 740915 compiler_unit_check(struct compiler_unit *u)
741 {
742 basicblock *block;
743
2/2
✓ Branch 0 taken 2153882 times.
✓ Branch 1 taken 740915 times.
 2894797 for (block = u->u_blocks; block != NULL; block = block->b_list) {
744 assert(!_PyMem_IsPtrFreed(block));
745 2153882 if (block->b_instr != NULL) {
746 assert(block->b_ialloc > 0);
747 assert(block->b_iused >= 0);
748 assert(block->b_ialloc >= block->b_iused);
749 }
750 else {
751 assert (block->b_iused == 0);
752 assert (block->b_ialloc == 0);
753 }
754 }
755 740915 }
756
757 static void
758 448800 compiler_unit_free(struct compiler_unit *u)
759 {
760 basicblock *b, *next;
761
762 448800 compiler_unit_check(u);
763 448800 b = u->u_blocks;
764
2/2
✓ Branch 0 taken 1380907 times.
✓ Branch 1 taken 448800 times.
 1829707 while (b != NULL) {
765
2/2
✓ Branch 0 taken 1308374 times.
✓ Branch 1 taken 72533 times.
 1380907 if (b->b_instr)
766 1308374 PyObject_Free((void *)b->b_instr);
767 1380907 next = b->b_list;
768 1380907 PyObject_Free((void *)b);
769 1380907 b = next;
770 }
771
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_ste);
772
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_name);
773
2/2
✓ Branch 0 taken 292115 times.
✓ Branch 1 taken 156685 times.
 448800 Py_CLEAR(u->u_qualname);
774
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_consts);
775
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_names);
776
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_varnames);
777
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_freevars);
778
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 Py_CLEAR(u->u_cellvars);
779
2/2
✓ Branch 0 taken 99263 times.
✓ Branch 1 taken 349537 times.
 448800 Py_CLEAR(u->u_private);
780 448800 PyObject_Free(u);
781 448800 }
782
783 static int
784 292115 compiler_set_qualname(struct compiler *c)
785 {
786 Py_ssize_t stack_size;
787 292115 struct compiler_unit *u = c->u;
788 PyObject *name, *base;
789
790 292115 base = NULL;
791 292115 stack_size = PyList_GET_SIZE(c->c_stack);
792 assert(stack_size >= 1);
793
2/2
✓ Branch 0 taken 108434 times.
✓ Branch 1 taken 183681 times.
 292115 if (stack_size > 1) {
794 108434 int scope, force_global = 0;
795 struct compiler_unit *parent;
796 PyObject *mangled, *capsule;
797
798 108434 capsule = PyList_GET_ITEM(c->c_stack, stack_size - 1);
799 108434 parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);
800 assert(parent);
801
802
2/2
✓ Branch 0 taken 23723 times.
✓ Branch 1 taken 84711 times.
 108434 if (u->u_scope_type == COMPILER_SCOPE_FUNCTION
803
2/2
✓ Branch 0 taken 22662 times.
✓ Branch 1 taken 1061 times.
 23723 || u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION
804
2/2
✓ Branch 0 taken 947 times.
✓ Branch 1 taken 21715 times.
 22662 || u->u_scope_type == COMPILER_SCOPE_CLASS) {
805 assert(u->u_name);
806 86719 mangled = _Py_Mangle(parent->u_private, u->u_name);
807
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86719 times.
 86719 if (!mangled)
808 ✗ return 0;
809 86719 scope = _PyST_GetScope(parent->u_ste, mangled);
810 86719 Py_DECREF(mangled);
811 assert(scope != GLOBAL_IMPLICIT);
812
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 86718 times.
 86719 if (scope == GLOBAL_EXPLICIT)
813 1 force_global = 1;
814 }
815
816
2/2
✓ Branch 0 taken 108433 times.
✓ Branch 1 taken 1 times.
 108434 if (!force_global) {
817
2/2
✓ Branch 0 taken 73879 times.
✓ Branch 1 taken 34554 times.
 108433 if (parent->u_scope_type == COMPILER_SCOPE_FUNCTION
818
2/2
✓ Branch 0 taken 73756 times.
✓ Branch 1 taken 123 times.
 73879 || parent->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION
819
2/2
✓ Branch 0 taken 123 times.
✓ Branch 1 taken 73633 times.
 73756 || parent->u_scope_type == COMPILER_SCOPE_LAMBDA)
820 {
821 _Py_DECLARE_STR(dot_locals, ".<locals>");
822 34800 base = PyUnicode_Concat(parent->u_qualname,
823 &_Py_STR(dot_locals));
824
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 34800 times.
 34800 if (base == NULL)
825 ✗ return 0;
826 }
827 else {
828 73633 Py_INCREF(parent->u_qualname);
829 73633 base = parent->u_qualname;
830 }
831 }
832 }
833
834
2/2
✓ Branch 0 taken 108433 times.
✓ Branch 1 taken 183682 times.
 292115 if (base != NULL) {
835 _Py_DECLARE_STR(dot, ".");
836 108433 name = PyUnicode_Concat(base, &_Py_STR(dot));
837 108433 Py_DECREF(base);
838
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108433 times.
 108433 if (name == NULL)
839 ✗ return 0;
840 108433 PyUnicode_Append(&name, u->u_name);
841
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108433 times.
 108433 if (name == NULL)
842 ✗ return 0;
843 }
844 else {
845 183682 Py_INCREF(u->u_name);
846 183682 name = u->u_name;
847 }
848 292115 u->u_qualname = name;
849
850 292115 return 1;
851 }
852
853
854 /* Allocate a new block and return a pointer to it.
855 Returns NULL on error.
856 */
857 static basicblock *
858 1380907 new_basicblock()
859 {
860 1380907 basicblock *b = (basicblock *)PyObject_Calloc(1, sizeof(basicblock));
861
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1380907 times.
 1380907 if (b == NULL) {
862 ✗ PyErr_NoMemory();
863 ✗ return NULL;
864 }
865 1380907 return b;
866 }
867
868 static basicblock *
869 1366225 compiler_new_block(struct compiler *c)
870 {
871 1366225 basicblock *b = new_basicblock();
872
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1366225 times.
 1366225 if (b == NULL) {
873 ✗ return NULL;
874 }
875 /* Extend the singly linked list of blocks with new block. */
876 1366225 struct compiler_unit *u = c->u;
877 1366225 b->b_list = u->u_blocks;
878 1366225 u->u_blocks = b;
879 1366225 return b;
880 }
881
882 static basicblock *
883 917425 compiler_use_next_block(struct compiler *c, basicblock *block)
884 {
885 assert(block != NULL);
886 917425 c->u->u_curblock->b_next = block;
887 917425 c->u->u_curblock = block;
888 917425 return block;
889 }
890
891 static basicblock *
892 14682 basicblock_new_b_list_successor(basicblock *prev)
893 {
894 14682 basicblock *result = new_basicblock();
895
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14682 times.
 14682 if (result == NULL) {
896 ✗ return NULL;
897 }
898 14682 result->b_list = prev->b_list;
899 14682 prev->b_list = result;
900 14682 return result;
901 }
902
903 static basicblock *
904 14660 copy_basicblock(basicblock *block)
905 {
906 /* Cannot copy a block if it has a fallthrough, since
907 * a block can only have one fallthrough predecessor.
908 */
909 assert(BB_NO_FALLTHROUGH(block));
910 14660 basicblock *result = basicblock_new_b_list_successor(block);
911
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14660 times.
 14660 if (result == NULL) {
912 ✗ return NULL;
913 }
914
2/2
✓ Branch 0 taken 35278 times.
✓ Branch 1 taken 14660 times.
 49938 for (int i = 0; i < block->b_iused; i++) {
915 35278 int n = basicblock_next_instr(result);
916
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35278 times.
 35278 if (n < 0) {
917 ✗ return NULL;
918 }
919 35278 result->b_instr[n] = block->b_instr[i];
920 }
921 14660 return result;
922 }
923
924 /* Returns the offset of the next instruction in the current block's
925 b_instr array. Resizes the b_instr as necessary.
926 Returns -1 on failure.
927 */
928
929 static int
930 15833640 basicblock_next_instr(basicblock *b)
931 {
932 assert(b != NULL);
933
2/2
✓ Branch 0 taken 1308374 times.
✓ Branch 1 taken 14525266 times.
 15833640 if (b->b_instr == NULL) {
934 1308374 b->b_instr = (struct instr *)PyObject_Calloc(
935 DEFAULT_BLOCK_SIZE, sizeof(struct instr));
936
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1308374 times.
 1308374 if (b->b_instr == NULL) {
937 ✗ PyErr_NoMemory();
938 ✗ return -1;
939 }
940 1308374 b->b_ialloc = DEFAULT_BLOCK_SIZE;
941 }
942
2/2
✓ Branch 0 taken 262437 times.
✓ Branch 1 taken 14262829 times.
 14525266 else if (b->b_iused == b->b_ialloc) {
943 struct instr *tmp;
944 size_t oldsize, newsize;
945 262437 oldsize = b->b_ialloc * sizeof(struct instr);
946 262437 newsize = oldsize << 1;
947
948
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 262437 times.
 262437 if (oldsize > (SIZE_MAX >> 1)) {
949 ✗ PyErr_NoMemory();
950 ✗ return -1;
951 }
952
953
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 262437 times.
 262437 if (newsize == 0) {
954 ✗ PyErr_NoMemory();
955 ✗ return -1;
956 }
957 262437 b->b_ialloc <<= 1;
958 262437 tmp = (struct instr *)PyObject_Realloc(
959 262437 (void *)b->b_instr, newsize);
960
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 262437 times.
 262437 if (tmp == NULL) {
961 ✗ PyErr_NoMemory();
962 ✗ return -1;
963 }
964 262437 b->b_instr = tmp;
965 262437 memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);
966 }
967 15833640 return b->b_iused++;
968 }
969
970 /* Set the line number and column offset for the following instructions.
971
972 The line number is reset in the following cases:
973 - when entering a new scope
974 - on each statement
975 - on each expression and sub-expression
976 - before the "except" and "finally" clauses
977 */
978
979 #define SET_LOC(c, x) \
980 (c)->u->u_loc.lineno = (x)->lineno; \
981 (c)->u->u_loc.end_lineno = (x)->end_lineno; \
982 (c)->u->u_loc.col_offset = (x)->col_offset; \
983 (c)->u->u_loc.end_col_offset = (x)->end_col_offset;
984
985 // Artificial instructions
986 #define UNSET_LOC(c) \
987 (c)->u->u_loc.lineno = -1; \
988 (c)->u->u_loc.end_lineno = -1; \
989 (c)->u->u_loc.col_offset = -1; \
990 (c)->u->u_loc.end_col_offset = -1;
991
992
993 /* Return the stack effect of opcode with argument oparg.
994
995 Some opcodes have different stack effect when jump to the target and
996 when not jump. The 'jump' parameter specifies the case:
997
998 * 0 -- when not jump
999 * 1 -- when jump
1000 * -1 -- maximal
1001 */
1002 static int
1003 15033227 stack_effect(int opcode, int oparg, int jump)
1004 {
1005
75/81
✓ Branch 0 taken 469054 times.
✓ Branch 1 taken 249989 times.
✓ Branch 2 taken 12511 times.
✓ Branch 3 taken 47921 times.
✓ Branch 4 taken 32637 times.
✓ Branch 5 taken 122676 times.
✓ Branch 6 taken 134253 times.
✓ Branch 7 taken 24281 times.
✓ Branch 8 taken 1167 times.
✓ Branch 9 taken 50361 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 15204 times.
✓ Branch 12 taken 514681 times.
✓ Branch 13 taken 1358 times.
✓ Branch 14 taken 487 times.
✓ Branch 15 taken 11915 times.
✓ Branch 16 taken 33655 times.
✓ Branch 17 taken 31999 times.
✓ Branch 18 taken 366037 times.
✓ Branch 19 taken 378 times.
✓ Branch 20 taken 36259 times.
✓ Branch 21 taken 37 times.
✓ Branch 22 taken 100734 times.
✓ Branch 23 taken 3316 times.
✓ Branch 24 taken 72050 times.
✓ Branch 25 taken 161 times.
✓ Branch 26 taken 972 times.
✓ Branch 27 taken 4 times.
✓ Branch 28 taken 2193257 times.
✓ Branch 29 taken 226484 times.
✓ Branch 30 taken 290457 times.
✓ Branch 31 taken 28632 times.
✓ Branch 32 taken 9699 times.
✓ Branch 33 taken 707499 times.
✓ Branch 34 taken 153260 times.
✓ Branch 35 taken 11683 times.
✗ Branch 36 not taken.
✓ Branch 37 taken 56055 times.
✓ Branch 38 taken 82392 times.
✓ Branch 39 taken 194860 times.
✓ Branch 40 taken 26856 times.
✓ Branch 41 taken 540296 times.
✓ Branch 42 taken 1750259 times.
✓ Branch 43 taken 26726 times.
✓ Branch 44 taken 39502 times.
✓ Branch 45 taken 8722 times.
✗ Branch 46 not taken.
✓ Branch 47 taken 37463 times.
✓ Branch 48 taken 17721 times.
✓ Branch 49 taken 4361 times.
✓ Branch 50 taken 2285391 times.
✓ Branch 51 taken 471886 times.
✓ Branch 52 taken 3359 times.
✓ Branch 53 taken 9384 times.
✓ Branch 54 taken 100017 times.
✓ Branch 55 taken 53716 times.
✓ Branch 56 taken 1411306 times.
✓ Branch 57 taken 17575 times.
✓ Branch 58 taken 292108 times.
✓ Branch 59 taken 11373 times.
✓ Branch 60 taken 38916 times.
✓ Branch 61 taken 30119 times.
✓ Branch 62 taken 75370 times.
✓ Branch 63 taken 11697 times.
✓ Branch 64 taken 4 times.
✓ Branch 65 taken 1109 times.
✓ Branch 66 taken 4361 times.
✓ Branch 67 taken 3 times.
✓ Branch 68 taken 3 times.
✓ Branch 69 taken 546 times.
✓ Branch 70 taken 3 times.
✓ Branch 71 taken 33779 times.
✗ Branch 72 not taken.
✓ Branch 73 taken 78672 times.
✓ Branch 74 taken 4919 times.
✓ Branch 75 taken 32829 times.
✓ Branch 76 taken 4 times.
✗ Branch 77 not taken.
✓ Branch 78 taken 140965 times.
✓ Branch 79 taken 1183532 times.
✗ Branch 80 not taken.
 15033227 switch (opcode) {
1006 469054 case NOP:
1007 case EXTENDED_ARG:
1008 case RESUME:
1009 case CACHE:
1010 469054 return 0;
1011
1012 /* Stack manipulation */
1013 249989 case POP_TOP:
1014 249989 return -1;
1015 12511 case SWAP:
1016 12511 return 0;
1017
1018 /* Unary operators */
1019 47921 case UNARY_POSITIVE:
1020 case UNARY_NEGATIVE:
1021 case UNARY_NOT:
1022 case UNARY_INVERT:
1023 47921 return 0;
1024
1025 32637 case SET_ADD:
1026 case LIST_APPEND:
1027 32637 return -1;
1028 122676 case MAP_ADD:
1029 122676 return -2;
1030
1031 134253 case BINARY_SUBSCR:
1032 134253 return -1;
1033 24281 case STORE_SUBSCR:
1034 24281 return -3;
1035 1167 case DELETE_SUBSCR:
1036 1167 return -2;
1037
1038 50361 case GET_ITER:
1039 50361 return 0;
1040
1041 ✗ case PRINT_EXPR:
1042 ✗ return -1;
1043 15204 case LOAD_BUILD_CLASS:
1044 15204 return 1;
1045
1046 514681 case RETURN_VALUE:
1047 514681 return -1;
1048 1358 case IMPORT_STAR:
1049 1358 return -1;
1050 487 case SETUP_ANNOTATIONS:
1051 487 return 0;
1052 11915 case ASYNC_GEN_WRAP:
1053 case YIELD_VALUE:
1054 11915 return 0;
1055 33655 case POP_BLOCK:
1056 33655 return 0;
1057 31999 case POP_EXCEPT:
1058 31999 return -1;
1059
1060 366037 case STORE_NAME:
1061 366037 return -1;
1062 378 case DELETE_NAME:
1063 378 return 0;
1064 36259 case UNPACK_SEQUENCE:
1065 36259 return oparg-1;
1066 37 case UNPACK_EX:
1067 37 return (oparg&0xFF) + (oparg>>8);
1068 100734 case FOR_ITER:
1069 /* -1 at end of iterator, 1 if continue iterating. */
1070
2/2
✓ Branch 0 taken 50367 times.
✓ Branch 1 taken 50367 times.
 100734 return jump > 0 ? -1 : 1;
1071 3316 case SEND:
1072
2/2
✓ Branch 0 taken 1658 times.
✓ Branch 1 taken 1658 times.
 3316 return jump > 0 ? -1 : 0;
1073 72050 case STORE_ATTR:
1074 72050 return -2;
1075 161 case DELETE_ATTR:
1076 161 return -1;
1077 972 case STORE_GLOBAL:
1078 972 return -1;
1079 4 case DELETE_GLOBAL:
1080 4 return 0;
1081 2193257 case LOAD_CONST:
1082 2193257 return 1;
1083 226484 case LOAD_NAME:
1084 226484 return 1;
1085 290457 case BUILD_TUPLE:
1086 case BUILD_LIST:
1087 case BUILD_SET:
1088 case BUILD_STRING:
1089 290457 return 1-oparg;
1090 28632 case BUILD_MAP:
1091 28632 return 1 - 2*oparg;
1092 9699 case BUILD_CONST_KEY_MAP:
1093 9699 return -oparg;
1094 707499 case LOAD_ATTR:
1095 707499 return (oparg & 1);
1096 153260 case COMPARE_OP:
1097 case IS_OP:
1098 case CONTAINS_OP:
1099 153260 return -1;
1100 11683 case CHECK_EXC_MATCH:
1101 11683 return 0;
1102 ✗ case CHECK_EG_MATCH:
1103 ✗ return 0;
1104 56055 case IMPORT_NAME:
1105 56055 return -1;
1106 82392 case IMPORT_FROM:
1107 82392 return 1;
1108
1109 /* Jumps */
1110 194860 case JUMP_FORWARD:
1111 case JUMP_BACKWARD:
1112 case JUMP:
1113 case JUMP_BACKWARD_NO_INTERRUPT:
1114 case JUMP_NO_INTERRUPT:
1115 194860 return 0;
1116
1117 26856 case JUMP_IF_TRUE_OR_POP:
1118 case JUMP_IF_FALSE_OR_POP:
1119
2/2
✓ Branch 0 taken 13428 times.
✓ Branch 1 taken 13428 times.
 26856 return jump ? 0 : -1;
1120
1121 540296 case POP_JUMP_BACKWARD_IF_NONE:
1122 case POP_JUMP_FORWARD_IF_NONE:
1123 case POP_JUMP_IF_NONE:
1124 case POP_JUMP_BACKWARD_IF_NOT_NONE:
1125 case POP_JUMP_FORWARD_IF_NOT_NONE:
1126 case POP_JUMP_IF_NOT_NONE:
1127 case POP_JUMP_FORWARD_IF_FALSE:
1128 case POP_JUMP_BACKWARD_IF_FALSE:
1129 case POP_JUMP_IF_FALSE:
1130 case POP_JUMP_FORWARD_IF_TRUE:
1131 case POP_JUMP_BACKWARD_IF_TRUE:
1132 case POP_JUMP_IF_TRUE:
1133 540296 return -1;
1134
1135 1750259 case LOAD_GLOBAL:
1136 1750259 return (oparg & 1) + 1;
1137
1138 /* Exception handling pseudo-instructions */
1139 26726 case SETUP_FINALLY:
1140 /* 0 in the normal flow.
1141 * Restore the stack position and push 1 value before jumping to
1142 * the handler if an exception be raised. */
1143 26726 return jump ? 1 : 0;
1144 39502 case SETUP_CLEANUP:
1145 /* As SETUP_FINALLY, but pushes lasti as well */
1146
2/2
✓ Branch 0 taken 19751 times.
✓ Branch 1 taken 19751 times.
 39502 return jump ? 2 : 0;
1147 8722 case SETUP_WITH:
1148 /* 0 in the normal flow.
1149 * Restore the stack position to the position before the result
1150 * of __(a)enter__ and push 2 values before jumping to the handler
1151 * if an exception be raised. */
1152 8722 return jump ? 1 : 0;
1153
1154 ✗ case PREP_RERAISE_STAR:
1155 ✗ return -1;
1156 37463 case RERAISE:
1157 37463 return -1;
1158 17721 case PUSH_EXC_INFO:
1159 17721 return 1;
1160
1161 4361 case WITH_EXCEPT_START:
1162 4361 return 1;
1163
1164 2285391 case LOAD_FAST:
1165 case LOAD_FAST_CHECK:
1166 2285391 return 1;
1167 471886 case STORE_FAST:
1168 471886 return -1;
1169 3359 case DELETE_FAST:
1170 3359 return 0;
1171
1172 9384 case RETURN_GENERATOR:
1173 9384 return 0;
1174
1175 100017 case RAISE_VARARGS:
1176 100017 return -oparg;
1177
1178 /* Functions and calls */
1179 53716 case KW_NAMES:
1180 53716 return 0;
1181 1411306 case CALL:
1182 1411306 return -1-oparg;
1183
1184 17575 case CALL_FUNCTION_EX:
1185
2/2
✓ Branch 0 taken 10318 times.
✓ Branch 1 taken 7257 times.
 17575 return -2 - ((oparg & 0x01) != 0);
1186 292108 case MAKE_FUNCTION:
1187 292108 return 0 - ((oparg & 0x01) != 0) - ((oparg & 0x02) != 0) -
1188 292108 ((oparg & 0x04) != 0) - ((oparg & 0x08) != 0);
1189 11373 case BUILD_SLICE:
1190
2/2
✓ Branch 0 taken 455 times.
✓ Branch 1 taken 10918 times.
 11373 if (oparg == 3)
1191 455 return -2;
1192 else
1193 10918 return -1;
1194
1195 /* Closures */
1196 38916 case MAKE_CELL:
1197 case COPY_FREE_VARS:
1198 38916 return 0;
1199 30119 case LOAD_CLOSURE:
1200 30119 return 1;
1201 75370 case LOAD_DEREF:
1202 case LOAD_CLASSDEREF:
1203 75370 return 1;
1204 11697 case STORE_DEREF:
1205 11697 return -1;
1206 4 case DELETE_DEREF:
1207 4 return 0;
1208
1209 /* Iterators and generators */
1210 1109 case GET_AWAITABLE:
1211 1109 return 0;
1212
1213 4361 case BEFORE_ASYNC_WITH:
1214 case BEFORE_WITH:
1215 4361 return 1;
1216 3 case GET_AITER:
1217 3 return 0;
1218 3 case GET_ANEXT:
1219 3 return 1;
1220 546 case GET_YIELD_FROM_ITER:
1221 546 return 0;
1222 3 case END_ASYNC_FOR:
1223 3 return -2;
1224 33779 case FORMAT_VALUE:
1225 /* If there's a fmt_spec on the stack, we go from 2->1,
1226 else 1->1. */
1227
2/2
✓ Branch 0 taken 77 times.
✓ Branch 1 taken 33702 times.
 33779 return (oparg & FVS_MASK) == FVS_HAVE_SPEC ? -1 : 0;
1228 ✗ case LOAD_METHOD:
1229 ✗ return 1;
1230 78672 case LOAD_ASSERTION_ERROR:
1231 78672 return 1;
1232 4919 case LIST_TO_TUPLE:
1233 4919 return 0;
1234 32829 case LIST_EXTEND:
1235 case SET_UPDATE:
1236 case DICT_MERGE:
1237 case DICT_UPDATE:
1238 32829 return -1;
1239 4 case MATCH_CLASS:
1240 4 return -2;
1241 ✗ case GET_LEN:
1242 case MATCH_MAPPING:
1243 case MATCH_SEQUENCE:
1244 case MATCH_KEYS:
1245 ✗ return 1;
1246 140965 case COPY:
1247 case PUSH_NULL:
1248 140965 return 1;
1249 1183532 case BINARY_OP:
1250 1183532 return -1;
1251 ✗ default:
1252 ✗ return PY_INVALID_STACK_EFFECT;
1253 }
1254 return PY_INVALID_STACK_EFFECT; /* not reachable */
1255 }
1256
1257 int
1258 ✗ PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump)
1259 {
1260 ✗ return stack_effect(opcode, oparg, jump);
1261 }
1262
1263 int
1264 ✗ PyCompile_OpcodeStackEffect(int opcode, int oparg)
1265 {
1266 ✗ return stack_effect(opcode, oparg, -1);
1267 }
1268
1269 static int
1270 14679350 is_end_of_basic_block(struct instr *instr)
1271 {
1272 14679350 int opcode = instr->i_opcode;
1273
7/8
✓ Branch 1 taken 14404101 times.
✓ Branch 2 taken 275249 times.
✓ Branch 3 taken 14386470 times.
✓ Branch 4 taken 17631 times.
✓ Branch 5 taken 14380007 times.
✓ Branch 6 taken 6463 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 14380007 times.
 14679350 return is_jump(instr) || IS_SCOPE_EXIT_OPCODE(opcode);
1274 }
1275
1276 static int
1277 15673699 compiler_use_new_implicit_block_if_needed(struct compiler *c)
1278 {
1279 15673699 basicblock *b = c->u->u_curblock;
1280
4/4
✓ Branch 0 taken 14679350 times.
✓ Branch 1 taken 994349 times.
✓ Branch 4 taken 299343 times.
✓ Branch 5 taken 14380007 times.
 15673699 if (b->b_iused && is_end_of_basic_block(basicblock_last_instr(b))) {
1281 299343 basicblock *b = compiler_new_block(c);
1282
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 299343 times.
 299343 if (b == NULL) {
1283 ✗ return -1;
1284 }
1285 299343 compiler_use_next_block(c, b);
1286 }
1287 15673699 return 0;
1288 }
1289
1290 /* Add an opcode with no argument.
1291 Returns 0 on failure, 1 on success.
1292 */
1293
1294 static int
1295 15673721 basicblock_addop(basicblock *b, int opcode, int oparg,
1296 basicblock *target, const struct location *loc)
1297 {
1298 assert(IS_WITHIN_OPCODE_RANGE(opcode));
1299 assert(!IS_ASSEMBLER_OPCODE(opcode));
1300 assert(HAS_ARG(opcode) || oparg == 0);
1301 assert(0 <= oparg && oparg < (1 << 30));
1302 assert((target == NULL) ||
1303 IS_JUMP_OPCODE(opcode) ||
1304 IS_BLOCK_PUSH_OPCODE(opcode));
1305 assert(oparg == 0 || target == NULL);
1306
1307 15673721 int off = basicblock_next_instr(b);
1308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15673721 times.
 15673721 if (off < 0) {
1309 ✗ return 0;
1310 }
1311 15673721 struct instr *i = &b->b_instr[off];
1312 15673721 i->i_opcode = opcode;
1313 15673721 i->i_oparg = oparg;
1314 15673721 i->i_target = target;
1315
2/2
✓ Branch 0 taken 15591786 times.
✓ Branch 1 taken 81935 times.
 15673721 i->i_loc = loc ? *loc : NO_LOCATION;
1316
1317 15673721 return 1;
1318 }
1319
1320 static int
1321 2377771 compiler_addop(struct compiler *c, int opcode, bool line)
1322 {
1323 assert(!HAS_ARG(opcode) || IS_ARTIFICIAL(opcode));
1324
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2377771 times.
 2377771 if (compiler_use_new_implicit_block_if_needed(c) < 0) {
1325 ✗ return -1;
1326 }
1327
1328
2/2
✓ Branch 0 taken 2364406 times.
✓ Branch 1 taken 13365 times.
 2377771 const struct location *loc = line ? &c->u->u_loc : NULL;
1329 2377771 return basicblock_addop(c->u->u_curblock, opcode, 0, NULL, loc);
1330 }
1331
1332 static Py_ssize_t
1333 8638041 compiler_add_o(PyObject *dict, PyObject *o)
1334 {
1335 PyObject *v;
1336 Py_ssize_t arg;
1337
1338 8638041 v = PyDict_GetItemWithError(dict, o);
1339
2/2
✓ Branch 0 taken 3100589 times.
✓ Branch 1 taken 5537452 times.
 8638041 if (!v) {
1340
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3100589 times.
 3100589 if (PyErr_Occurred()) {
1341 ✗ return -1;
1342 }
1343 3100589 arg = PyDict_GET_SIZE(dict);
1344 3100589 v = PyLong_FromSsize_t(arg);
1345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3100589 times.
 3100589 if (!v) {
1346 ✗ return -1;
1347 }
1348
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3100589 times.
 3100589 if (PyDict_SetItem(dict, o, v) < 0) {
1349 ✗ Py_DECREF(v);
1350 ✗ return -1;
1351 }
1352 3100589 Py_DECREF(v);
1353 }
1354 else
1355 5537452 arg = PyLong_AsLong(v);
1356 8638041 return arg;
1357 }
1358
1359 // Merge const *o* recursively and return constant key object.
1360 static PyObject*
1361 2956911 merge_consts_recursive(PyObject *const_cache, PyObject *o)
1362 {
1363 assert(PyDict_CheckExact(const_cache));
1364 // None and Ellipsis are singleton, and key is the singleton.
1365 // No need to merge object and key.
1366
4/4
✓ Branch 0 taken 2475354 times.
✓ Branch 1 taken 481557 times.
✓ Branch 2 taken 432 times.
✓ Branch 3 taken 2474922 times.
 2956911 if (o == Py_None || o == Py_Ellipsis) {
1367 481989 Py_INCREF(o);
1368 481989 return o;
1369 }
1370
1371 2474922 PyObject *key = _PyCode_ConstantKey(o);
1372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2474922 times.
 2474922 if (key == NULL) {
1373 ✗ return NULL;
1374 }
1375
1376 // t is borrowed reference
1377 2474922 PyObject *t = PyDict_SetDefault(const_cache, key, key);
1378
2/2
✓ Branch 0 taken 275858 times.
✓ Branch 1 taken 2199064 times.
 2474922 if (t != key) {
1379 // o is registered in const_cache. Just use it.
1380 275858 Py_XINCREF(t);
1381 275858 Py_DECREF(key);
1382 275858 return t;
1383 }
1384
1385 // We registered o in const_cache.
1386 // When o is a tuple or frozenset, we want to merge its
1387 // items too.
1388
2/2
✓ Branch 1 taken 100052 times.
✓ Branch 2 taken 2099012 times.
 2199064 if (PyTuple_CheckExact(o)) {
1389 100052 Py_ssize_t len = PyTuple_GET_SIZE(o);
1390
2/2
✓ Branch 0 taken 410937 times.
✓ Branch 1 taken 100052 times.
 510989 for (Py_ssize_t i = 0; i < len; i++) {
1391 410937 PyObject *item = PyTuple_GET_ITEM(o, i);
1392 410937 PyObject *u = merge_consts_recursive(const_cache, item);
1393
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410937 times.
 410937 if (u == NULL) {
1394 ✗ Py_DECREF(key);
1395 ✗ return NULL;
1396 }
1397
1398 // See _PyCode_ConstantKey()
1399 PyObject *v; // borrowed
1400
2/2
✓ Branch 1 taken 27268 times.
✓ Branch 2 taken 383669 times.
 410937 if (PyTuple_CheckExact(u)) {
1401 27268 v = PyTuple_GET_ITEM(u, 1);
1402 }
1403 else {
1404 383669 v = u;
1405 }
1406
2/2
✓ Branch 0 taken 25045 times.
✓ Branch 1 taken 385892 times.
 410937 if (v != item) {
1407 25045 Py_INCREF(v);
1408 25045 PyTuple_SET_ITEM(o, i, v);
1409 25045 Py_DECREF(item);
1410 }
1411
1412 410937 Py_DECREF(u);
1413 }
1414 }
1415
2/2
✓ Branch 1 taken 297 times.
✓ Branch 2 taken 2098715 times.
 2099012 else if (PyFrozenSet_CheckExact(o)) {
1416 // *key* is tuple. And its first item is frozenset of
1417 // constant keys.
1418 // See _PyCode_ConstantKey() for detail.
1419 assert(PyTuple_CheckExact(key));
1420 assert(PyTuple_GET_SIZE(key) == 2);
1421
1422 297 Py_ssize_t len = PySet_GET_SIZE(o);
1423
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297 times.
 297 if (len == 0) { // empty frozenset should not be re-created.
1424 ✗ return key;
1425 }
1426 297 PyObject *tuple = PyTuple_New(len);
1427
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297 times.
 297 if (tuple == NULL) {
1428 ✗ Py_DECREF(key);
1429 ✗ return NULL;
1430 }
1431 297 Py_ssize_t i = 0, pos = 0;
1432 PyObject *item;
1433 Py_hash_t hash;
1434
2/2
✓ Branch 1 taken 1852 times.
✓ Branch 2 taken 297 times.
 2149 while (_PySet_NextEntry(o, &pos, &item, &hash)) {
1435 1852 PyObject *k = merge_consts_recursive(const_cache, item);
1436
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1852 times.
 1852 if (k == NULL) {
1437 ✗ Py_DECREF(tuple);
1438 ✗ Py_DECREF(key);
1439 ✗ return NULL;
1440 }
1441 PyObject *u;
1442
2/2
✓ Branch 1 taken 110 times.
✓ Branch 2 taken 1742 times.
 1852 if (PyTuple_CheckExact(k)) {
1443 110 u = PyTuple_GET_ITEM(k, 1);
1444 110 Py_INCREF(u);
1445 110 Py_DECREF(k);
1446 }
1447 else {
1448 1742 u = k;
1449 }
1450 1852 PyTuple_SET_ITEM(tuple, i, u); // Steals reference of u.
1451 1852 i++;
1452 }
1453
1454 // Instead of rewriting o, we create new frozenset and embed in the
1455 // key tuple. Caller should get merged frozenset from the key tuple.
1456 297 PyObject *new = PyFrozenSet_New(tuple);
1457 297 Py_DECREF(tuple);
1458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 297 times.
 297 if (new == NULL) {
1459 ✗ Py_DECREF(key);
1460 ✗ return NULL;
1461 }
1462 assert(PyTuple_GET_ITEM(key, 1) == o);
1463 297 Py_DECREF(o);
1464 297 PyTuple_SET_ITEM(key, 1, new);
1465 }
1466
1467 2199064 return key;
1468 }
1469
1470 static Py_ssize_t
1471 2544122 compiler_add_const(struct compiler *c, PyObject *o)
1472 {
1473 2544122 PyObject *key = merge_consts_recursive(c->c_const_cache, o);
1474
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2544122 times.
 2544122 if (key == NULL) {
1475 ✗ return -1;
1476 }
1477
1478 2544122 Py_ssize_t arg = compiler_add_o(c->u->u_consts, key);
1479 2544122 Py_DECREF(key);
1480 2544122 return arg;
1481 }
1482
1483 static int
1484 2229512 compiler_addop_load_const(struct compiler *c, PyObject *o)
1485 {
1486 2229512 Py_ssize_t arg = compiler_add_const(c, o);
1487
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2229512 times.
 2229512 if (arg < 0)
1488 ✗ return 0;
1489 2229512 return compiler_addop_i(c, LOAD_CONST, arg, true);
1490 }
1491
1492 static int
1493 2745175 compiler_addop_o(struct compiler *c, int opcode, PyObject *dict,
1494 PyObject *o)
1495 {
1496 2745175 Py_ssize_t arg = compiler_add_o(dict, o);
1497
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2745175 times.
 2745175 if (arg < 0)
1498 ✗ return 0;
1499 2745175 return compiler_addop_i(c, opcode, arg, true);
1500 }
1501
1502 static int
1503 919167 compiler_addop_name(struct compiler *c, int opcode, PyObject *dict,
1504 PyObject *o)
1505 {
1506 Py_ssize_t arg;
1507
1508 919167 PyObject *mangled = _Py_Mangle(c->u->u_private, o);
1509
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 919167 times.
 919167 if (!mangled)
1510 ✗ return 0;
1511 919167 arg = compiler_add_o(dict, mangled);
1512 919167 Py_DECREF(mangled);
1513
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 919167 times.
 919167 if (arg < 0)
1514 ✗ return 0;
1515
2/2
✓ Branch 0 taken 450095 times.
✓ Branch 1 taken 469072 times.
 919167 if (opcode == LOAD_ATTR) {
1516 450095 arg <<= 1;
1517 }
1518
2/2
✓ Branch 0 taken 258177 times.
✓ Branch 1 taken 660990 times.
 919167 if (opcode == LOAD_METHOD) {
1519 258177 opcode = LOAD_ATTR;
1520 258177 arg <<= 1;
1521 258177 arg |= 1;
1522 }
1523 919167 return compiler_addop_i(c, opcode, arg, true);
1524 }
1525
1526 /* Add an opcode with an integer argument.
1527 Returns 0 on failure, 1 on success.
1528 */
1529 static int
1530 12777944 compiler_addop_i(struct compiler *c, int opcode, Py_ssize_t oparg, bool line)
1531 {
1532
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12777944 times.
 12777944 if (compiler_use_new_implicit_block_if_needed(c) < 0) {
1533 ✗ return -1;
1534 }
1535 /* oparg value is unsigned, but a signed C int is usually used to store
1536 it in the C code (like Python/ceval.c).
1537
1538 Limit to 32-bit signed C int (rather than INT_MAX) for portability.
1539
1540 The argument of a concrete bytecode instruction is limited to 8-bit.
1541 EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */
1542
1543 12777944 int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);
1544
1545
2/2
✓ Branch 0 taken 12773642 times.
✓ Branch 1 taken 4302 times.
 12777944 const struct location *loc = line ? &c->u->u_loc : NULL;
1546 12777944 return basicblock_addop(c->u->u_curblock, opcode, oparg_, NULL, loc);
1547 }
1548
1549 static int
1550 517984 compiler_addop_j(struct compiler *c, int opcode, basicblock *target, bool line)
1551 {
1552
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 517984 times.
 517984 if (compiler_use_new_implicit_block_if_needed(c) < 0) {
1553 ✗ return -1;
1554 }
1555
2/2
✓ Branch 0 taken 453716 times.
✓ Branch 1 taken 64268 times.
 517984 const struct location *loc = line ? &c->u->u_loc : NULL;
1556 assert(target != NULL);
1557 assert(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode));
1558 517984 return basicblock_addop(c->u->u_curblock, opcode, 0, target, loc);
1559 }
1560
1561 #define ADDOP(C, OP) { \
1562 if (!compiler_addop((C), (OP), true)) \
1563 return 0; \
1564 }
1565
1566 #define ADDOP_NOLINE(C, OP) { \
1567 if (!compiler_addop((C), (OP), false)) \
1568 return 0; \
1569 }
1570
1571 #define ADDOP_IN_SCOPE(C, OP) { \
1572 if (!compiler_addop((C), (OP), true)) { \
1573 compiler_exit_scope(c); \
1574 return 0; \
1575 } \
1576 }
1577
1578 #define ADDOP_LOAD_CONST(C, O) { \
1579 if (!compiler_addop_load_const((C), (O))) \
1580 return 0; \
1581 }
1582
1583 /* Same as ADDOP_LOAD_CONST, but steals a reference. */
1584 #define ADDOP_LOAD_CONST_NEW(C, O) { \
1585 PyObject *__new_const = (O); \
1586 if (__new_const == NULL) { \
1587 return 0; \
1588 } \
1589 if (!compiler_addop_load_const((C), __new_const)) { \
1590 Py_DECREF(__new_const); \
1591 return 0; \
1592 } \
1593 Py_DECREF(__new_const); \
1594 }
1595
1596 #define ADDOP_N(C, OP, O, TYPE) { \
1597 assert(!HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \
1598 if (!compiler_addop_o((C), (OP), (C)->u->u_ ## TYPE, (O))) { \
1599 Py_DECREF((O)); \
1600 return 0; \
1601 } \
1602 Py_DECREF((O)); \
1603 }
1604
1605 #define ADDOP_NAME(C, OP, O, TYPE) { \
1606 if (!compiler_addop_name((C), (OP), (C)->u->u_ ## TYPE, (O))) \
1607 return 0; \
1608 }
1609
1610 #define ADDOP_I(C, OP, O) { \
1611 if (!compiler_addop_i((C), (OP), (O), true)) \
1612 return 0; \
1613 }
1614
1615 #define ADDOP_I_NOLINE(C, OP, O) { \
1616 if (!compiler_addop_i((C), (OP), (O), false)) \
1617 return 0; \
1618 }
1619
1620 #define ADDOP_JUMP(C, OP, O) { \
1621 if (!compiler_addop_j((C), (OP), (O), true)) \
1622 return 0; \
1623 }
1624
1625 /* Add a jump with no line number.
1626 * Used for artificial jumps that have no corresponding
1627 * token in the source code. */
1628 #define ADDOP_JUMP_NOLINE(C, OP, O) { \
1629 if (!compiler_addop_j((C), (OP), (O), false)) \
1630 return 0; \
1631 }
1632
1633 #define ADDOP_COMPARE(C, CMP) { \
1634 if (!compiler_addcompare((C), (cmpop_ty)(CMP))) \
1635 return 0; \
1636 }
1637
1638 #define ADDOP_BINARY(C, BINOP) \
1639 RETURN_IF_FALSE(addop_binary((C), (BINOP), false))
1640
1641 #define ADDOP_INPLACE(C, BINOP) \
1642 RETURN_IF_FALSE(addop_binary((C), (BINOP), true))
1643
1644 /* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use
1645 the ASDL name to synthesize the name of the C type and the visit function.
1646 */
1647
1648 #define ADD_YIELD_FROM(C, await) \
1649 RETURN_IF_FALSE(compiler_add_yield_from((C), (await)))
1650
1651 #define POP_EXCEPT_AND_RERAISE(C) \
1652 RETURN_IF_FALSE(compiler_pop_except_and_reraise((C)))
1653
1654 #define ADDOP_YIELD(C) \
1655 RETURN_IF_FALSE(addop_yield(C))
1656
1657 #define VISIT(C, TYPE, V) {\
1658 if (!compiler_visit_ ## TYPE((C), (V))) \
1659 return 0; \
1660 }
1661
1662 #define VISIT_IN_SCOPE(C, TYPE, V) {\
1663 if (!compiler_visit_ ## TYPE((C), (V))) { \
1664 compiler_exit_scope(c); \
1665 return 0; \
1666 } \
1667 }
1668
1669 #define VISIT_SEQ(C, TYPE, SEQ) { \
1670 int _i; \
1671 asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \
1672 for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
1673 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
1674 if (!compiler_visit_ ## TYPE((C), elt)) \
1675 return 0; \
1676 } \
1677 }
1678
1679 #define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \
1680 int _i; \
1681 asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \
1682 for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
1683 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
1684 if (!compiler_visit_ ## TYPE((C), elt)) { \
1685 compiler_exit_scope(c); \
1686 return 0; \
1687 } \
1688 } \
1689 }
1690
1691 #define RETURN_IF_FALSE(X) \
1692 if (!(X)) { \
1693 return 0; \
1694 }
1695
1696 static int
1697 448800 compiler_enter_scope(struct compiler *c, identifier name,
1698 int scope_type, void *key, int lineno)
1699 {
1700 struct compiler_unit *u;
1701 basicblock *block;
1702
1703 448800 u = (struct compiler_unit *)PyObject_Calloc(1, sizeof(
1704 struct compiler_unit));
1705
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!u) {
1706 ✗ PyErr_NoMemory();
1707 ✗ return 0;
1708 }
1709 448800 u->u_scope_type = scope_type;
1710 448800 u->u_argcount = 0;
1711 448800 u->u_posonlyargcount = 0;
1712 448800 u->u_kwonlyargcount = 0;
1713 448800 u->u_ste = PySymtable_Lookup(c->c_st, key);
1714
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!u->u_ste) {
1715 ✗ compiler_unit_free(u);
1716 ✗ return 0;
1717 }
1718 448800 Py_INCREF(name);
1719 448800 u->u_name = name;
1720 448800 u->u_varnames = list2dict(u->u_ste->ste_varnames);
1721 448800 u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
1722
2/4
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 448800 times.
 448800 if (!u->u_varnames || !u->u_cellvars) {
1723 ✗ compiler_unit_free(u);
1724 ✗ return 0;
1725 }
1726
2/2
✓ Branch 0 taken 2701 times.
✓ Branch 1 taken 446099 times.
 448800 if (u->u_ste->ste_needs_class_closure) {
1727 /* Cook up an implicit __class__ cell. */
1728 int res;
1729 assert(u->u_scope_type == COMPILER_SCOPE_CLASS);
1730 assert(PyDict_GET_SIZE(u->u_cellvars) == 0);
1731 2701 res = PyDict_SetItem(u->u_cellvars, &_Py_ID(__class__),
1732 _PyLong_GetZero());
1733
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2701 times.
 2701 if (res < 0) {
1734 ✗ compiler_unit_free(u);
1735 ✗ return 0;
1736 }
1737 }
1738
1739 448800 u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
1740 PyDict_GET_SIZE(u->u_cellvars));
1741
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!u->u_freevars) {
1742 ✗ compiler_unit_free(u);
1743 ✗ return 0;
1744 }
1745
1746 448800 u->u_blocks = NULL;
1747 448800 u->u_nfblocks = 0;
1748 448800 u->u_firstlineno = lineno;
1749 448800 u->u_loc = LOCATION(lineno, lineno, 0, 0);
1750 448800 u->u_consts = PyDict_New();
1751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!u->u_consts) {
1752 ✗ compiler_unit_free(u);
1753 ✗ return 0;
1754 }
1755 448800 u->u_names = PyDict_New();
1756
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!u->u_names) {
1757 ✗ compiler_unit_free(u);
1758 ✗ return 0;
1759 }
1760
1761 448800 u->u_private = NULL;
1762
1763 /* Push the old compiler_unit on the stack. */
1764
2/2
✓ Branch 0 taken 292115 times.
✓ Branch 1 taken 156685 times.
 448800 if (c->u) {
1765 292115 PyObject *capsule = PyCapsule_New(c->u, CAPSULE_NAME, NULL);
1766
2/4
✓ Branch 0 taken 292115 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 292115 times.
 292115 if (!capsule || PyList_Append(c->c_stack, capsule) < 0) {
1767 ✗ Py_XDECREF(capsule);
1768 ✗ compiler_unit_free(u);
1769 ✗ return 0;
1770 }
1771 292115 Py_DECREF(capsule);
1772 292115 u->u_private = c->u->u_private;
1773 292115 Py_XINCREF(u->u_private);
1774 }
1775 448800 c->u = u;
1776
1777 448800 c->c_nestlevel++;
1778
1779 448800 block = compiler_new_block(c);
1780
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (block == NULL)
1781 ✗ return 0;
1782 448800 c->u->u_curblock = block;
1783
1784
2/2
✓ Branch 0 taken 156685 times.
✓ Branch 1 taken 292115 times.
 448800 if (u->u_scope_type == COMPILER_SCOPE_MODULE) {
1785 156685 c->u->u_loc.lineno = -1;
1786 }
1787 else {
1788
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 292115 times.
 292115 if (!compiler_set_qualname(c))
1789 ✗ return 0;
1790 }
1791
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 ADDOP_I(c, RESUME, 0);
1792
1793 448800 return 1;
1794 }
1795
1796 static void
1797 448800 compiler_exit_scope(struct compiler *c)
1798 {
1799 // Don't call PySequence_DelItem() with an exception raised
1800 PyObject *exc_type, *exc_val, *exc_tb;
1801 448800 PyErr_Fetch(&exc_type, &exc_val, &exc_tb);
1802
1803 448800 c->c_nestlevel--;
1804 448800 compiler_unit_free(c->u);
1805 /* Restore c->u to the parent unit. */
1806 448800 Py_ssize_t n = PyList_GET_SIZE(c->c_stack) - 1;
1807
2/2
✓ Branch 0 taken 292115 times.
✓ Branch 1 taken 156685 times.
 448800 if (n >= 0) {
1808 292115 PyObject *capsule = PyList_GET_ITEM(c->c_stack, n);
1809 292115 c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);
1810 assert(c->u);
1811 /* we are deleting from a list so this really shouldn't fail */
1812
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 292115 times.
 292115 if (PySequence_DelItem(c->c_stack, n) < 0) {
1813 ✗ _PyErr_WriteUnraisableMsg("on removing the last compiler "
1814 "stack item", NULL);
1815 }
1816 292115 compiler_unit_check(c->u);
1817 }
1818 else {
1819 156685 c->u = NULL;
1820 }
1821
1822 448800 PyErr_Restore(exc_type, exc_val, exc_tb);
1823 448800 }
1824
1825 /* Search if variable annotations are present statically in a block. */
1826
1827 static int
1828 76109 find_ann(asdl_stmt_seq *stmts)
1829 {
1830 76109 int i, j, res = 0;
1831 stmt_ty st;
1832
1833
4/4
✓ Branch 0 taken 379936 times.
✓ Branch 1 taken 8508 times.
✓ Branch 2 taken 312828 times.
✓ Branch 3 taken 75616 times.
 388444 for (i = 0; i < asdl_seq_LEN(stmts); i++) {
1834 312828 st = (stmt_ty)asdl_seq_GET(stmts, i);
1835
7/10
✓ Branch 0 taken 487 times.
✓ Branch 1 taken 647 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 6438 times.
✓ Branch 5 taken 93 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 1492 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 303661 times.
 312828 switch (st->kind) {
1836 487 case AnnAssign_kind:
1837 487 return 1;
1838 647 case For_kind:
1839
2/4
✓ Branch 1 taken 647 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 647 times.
 1294 res = find_ann(st->v.For.body) ||
1840 647 find_ann(st->v.For.orelse);
1841 647 break;
1842 ✗ case AsyncFor_kind:
1843 ✗ res = find_ann(st->v.AsyncFor.body) ||
1844 ✗ find_ann(st->v.AsyncFor.orelse);
1845 ✗ break;
1846 10 case While_kind:
1847
2/4
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
 20 res = find_ann(st->v.While.body) ||
1848 10 find_ann(st->v.While.orelse);
1849 10 break;
1850 6438 case If_kind:
1851
3/4
✓ Branch 1 taken 6435 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6435 times.
 12873 res = find_ann(st->v.If.body) ||
1852 6435 find_ann(st->v.If.orelse);
1853 6438 break;
1854 93 case With_kind:
1855 93 res = find_ann(st->v.With.body);
1856 93 break;
1857 ✗ case AsyncWith_kind:
1858 ✗ res = find_ann(st->v.AsyncWith.body);
1859 ✗ break;
1860 1492 case Try_kind:
1861
4/4
✓ Branch 0 taken 2946 times.
✓ Branch 1 taken 23 times.
✓ Branch 2 taken 1477 times.
✓ Branch 3 taken 1492 times.
 2969 for (j = 0; j < asdl_seq_LEN(st->v.Try.handlers); j++) {
1862 1477 excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
1863 st->v.Try.handlers, j);
1864
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1477 times.
 1477 if (find_ann(handler->v.ExceptHandler.body)) {
1865 ✗ return 1;
1866 }
1867 }
1868
1/2
✓ Branch 1 taken 1492 times.
✗ Branch 2 not taken.
 2984 res = find_ann(st->v.Try.body) ||
1869
2/4
✓ Branch 0 taken 1492 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1492 times.
 2984 find_ann(st->v.Try.finalbody) ||
1870 1492 find_ann(st->v.Try.orelse);
1871 1492 break;
1872 ✗ case TryStar_kind:
1873 ✗ for (j = 0; j < asdl_seq_LEN(st->v.TryStar.handlers); j++) {
1874 ✗ excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
1875 st->v.TryStar.handlers, j);
1876 ✗ if (find_ann(handler->v.ExceptHandler.body)) {
1877 ✗ return 1;
1878 }
1879 }
1880 ✗ res = find_ann(st->v.TryStar.body) ||
1881 ✗ find_ann(st->v.TryStar.finalbody) ||
1882 ✗ find_ann(st->v.TryStar.orelse);
1883 ✗ break;
1884 303661 default:
1885 303661 res = 0;
1886 }
1887
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 312335 times.
 312341 if (res) {
1888 6 break;
1889 }
1890 }
1891 75622 return res;
1892 }
1893
1894 /*
1895 * Frame block handling functions
1896 */
1897
1898 static int
1899 81264 compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b,
1900 basicblock *exit, void *datum)
1901 {
1902 struct fblockinfo *f;
1903
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 81264 times.
 81264 if (c->u->u_nfblocks >= CO_MAXBLOCKS) {
1904 ✗ return compiler_error(c, "too many statically nested blocks");
1905 }
1906 81264 f = &c->u->u_fblock[c->u->u_nfblocks++];
1907 81264 f->fb_type = t;
1908 81264 f->fb_block = b;
1909 81264 f->fb_exit = exit;
1910 81264 f->fb_datum = datum;
1911 81264 return 1;
1912 }
1913
1914 static void
1915 81264 compiler_pop_fblock(struct compiler *c, enum fblocktype t, basicblock *b)
1916 {
1917 81264 struct compiler_unit *u = c->u;
1918 assert(u->u_nfblocks > 0);
1919 81264 u->u_nfblocks--;
1920 assert(u->u_fblock[u->u_nfblocks].fb_type == t);
1921 assert(u->u_fblock[u->u_nfblocks].fb_block == b);
1922 81264 }
1923
1924 static int
1925 5072 compiler_call_exit_with_nones(struct compiler *c) {
1926
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5072 times.
 5072 ADDOP_LOAD_CONST(c, Py_None);
1927
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5072 times.
 5072 ADDOP_LOAD_CONST(c, Py_None);
1928
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5072 times.
 5072 ADDOP_LOAD_CONST(c, Py_None);
1929
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5072 times.
 5072 ADDOP_I(c, CALL, 2);
1930 5072 return 1;
1931 }
1932
1933 static int
1934 1665 compiler_add_yield_from(struct compiler *c, int await)
1935 {
1936 basicblock *start, *resume, *exit;
1937 1665 start = compiler_new_block(c);
1938 1665 resume = compiler_new_block(c);
1939 1665 exit = compiler_new_block(c);
1940
3/6
✓ Branch 0 taken 1665 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1665 times.
 1665 if (start == NULL || resume == NULL || exit == NULL) {
1941 ✗ return 0;
1942 }
1943 1665 compiler_use_next_block(c, start);
1944
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
 1665 ADDOP_JUMP(c, SEND, exit);
1945 1665 compiler_use_next_block(c, resume);
1946
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
 1665 ADDOP_I(c, YIELD_VALUE, 0);
1947
3/4
✓ Branch 0 taken 1119 times.
✓ Branch 1 taken 546 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1665 times.
 1665 ADDOP_I(c, RESUME, await ? 3 : 2);
1948
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
 1665 ADDOP_JUMP(c, JUMP_NO_INTERRUPT, start);
1949 1665 compiler_use_next_block(c, exit);
1950 1665 return 1;
1951 }
1952
1953 static int
1954 17727 compiler_pop_except_and_reraise(struct compiler *c)
1955 {
1956 /* Stack contents
1957 * [exc_info, lasti, exc] COPY 3
1958 * [exc_info, lasti, exc, exc_info] POP_EXCEPT
1959 * [exc_info, lasti, exc] RERAISE 1
1960 * (exception_unwind clears the stack)
1961 */
1962
1963
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 17727 times.
 17727 ADDOP_I(c, COPY, 3);
1964
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 17727 times.
 17727 ADDOP(c, POP_EXCEPT);
1965
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 17727 times.
 17727 ADDOP_I(c, RERAISE, 1);
1966 17727 return 1;
1967 }
1968
1969 /* Unwind a frame block. If preserve_tos is true, the TOS before
1970 * popping the blocks will be restored afterwards, unless another
1971 * return, break or continue is found. In which case, the TOS will
1972 * be popped.
1973 */
1974 static int
1975 16764 compiler_unwind_fblock(struct compiler *c, struct fblockinfo *info,
1976 int preserve_tos)
1977 {
1978
7/9
✓ Branch 0 taken 5640 times.
✓ Branch 1 taken 3861 times.
✓ Branch 2 taken 2292 times.
✓ Branch 3 taken 600 times.
✓ Branch 4 taken 10 times.
✓ Branch 5 taken 710 times.
✓ Branch 6 taken 3651 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
 16764 switch (info->fb_type) {
1979 5640 case WHILE_LOOP:
1980 case EXCEPTION_HANDLER:
1981 case EXCEPTION_GROUP_HANDLER:
1982 case ASYNC_COMPREHENSION_GENERATOR:
1983 5640 return 1;
1984
1985 3861 case FOR_LOOP:
1986 /* Pop the iterator */
1987
2/2
✓ Branch 0 taken 1306 times.
✓ Branch 1 taken 2555 times.
 3861 if (preserve_tos) {
1988
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1306 times.
 1306 ADDOP_I(c, SWAP, 2);
1989 }
1990
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3861 times.
 3861 ADDOP(c, POP_TOP);
1991 3861 return 1;
1992
1993 2292 case TRY_EXCEPT:
1994
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2292 times.
 2292 ADDOP(c, POP_BLOCK);
1995 2292 return 1;
1996
1997 600 case FINALLY_TRY:
1998 /* This POP_BLOCK gets the line number of the unwinding statement */
1999
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 600 times.
 600 ADDOP(c, POP_BLOCK);
2000
2/2
✓ Branch 0 taken 241 times.
✓ Branch 1 taken 359 times.
 600 if (preserve_tos) {
2001
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 241 times.
 241 if (!compiler_push_fblock(c, POP_VALUE, NULL, NULL, NULL)) {
2002 ✗ return 0;
2003 }
2004 }
2005 /* Emit the finally block */
2006
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 664 times.
✓ Branch 3 taken 1264 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 664 times.
✓ Branch 6 taken 600 times.
 1264 VISIT_SEQ(c, stmt, info->fb_datum);
2007
2/2
✓ Branch 0 taken 241 times.
✓ Branch 1 taken 359 times.
 600 if (preserve_tos) {
2008 241 compiler_pop_fblock(c, POP_VALUE, NULL);
2009 }
2010 /* The finally block should appear to execute after the
2011 * statement causing the unwinding, so make the unwinding
2012 * instruction artificial */
2013 600 UNSET_LOC(c);
2014 600 return 1;
2015
2016 10 case FINALLY_END:
2017
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
 10 if (preserve_tos) {
2018
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADDOP_I(c, SWAP, 2);
2019 }
2020
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
 10 ADDOP(c, POP_TOP); /* exc_value */
2021
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
 10 if (preserve_tos) {
2022
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADDOP_I(c, SWAP, 2);
2023 }
2024
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
 10 ADDOP(c, POP_BLOCK);
2025
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
 10 ADDOP(c, POP_EXCEPT);
2026 10 return 1;
2027
2028 710 case WITH:
2029 case ASYNC_WITH:
2030 710 SET_LOC(c, (stmt_ty)info->fb_datum);
2031
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 710 times.
 710 ADDOP(c, POP_BLOCK);
2032
2/2
✓ Branch 0 taken 571 times.
✓ Branch 1 taken 139 times.
 710 if (preserve_tos) {
2033
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 571 times.
 571 ADDOP_I(c, SWAP, 2);
2034 }
2035
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 710 times.
 710 if(!compiler_call_exit_with_nones(c)) {
2036 ✗ return 0;
2037 }
2038
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 704 times.
 710 if (info->fb_type == ASYNC_WITH) {
2039
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADDOP_I(c, GET_AWAITABLE, 2);
2040
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADDOP_LOAD_CONST(c, Py_None);
2041
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADD_YIELD_FROM(c, 1);
2042 }
2043
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 710 times.
 710 ADDOP(c, POP_TOP);
2044 /* The exit block should appear to execute after the
2045 * statement causing the unwinding, so make the unwinding
2046 * instruction artificial */
2047 710 UNSET_LOC(c);
2048 710 return 1;
2049
2050 3651 case HANDLER_CLEANUP:
2051
2/2
✓ Branch 0 taken 356 times.
✓ Branch 1 taken 3295 times.
 3651 if (info->fb_datum) {
2052
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 356 times.
 356 ADDOP(c, POP_BLOCK);
2053 }
2054
2/2
✓ Branch 0 taken 1884 times.
✓ Branch 1 taken 1767 times.
 3651 if (preserve_tos) {
2055
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1884 times.
 1884 ADDOP_I(c, SWAP, 2);
2056 }
2057
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3651 times.
 3651 ADDOP(c, POP_BLOCK);
2058
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3651 times.
 3651 ADDOP(c, POP_EXCEPT);
2059
2/2
✓ Branch 0 taken 356 times.
✓ Branch 1 taken 3295 times.
 3651 if (info->fb_datum) {
2060
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 356 times.
 356 ADDOP_LOAD_CONST(c, Py_None);
2061 356 compiler_nameop(c, info->fb_datum, Store);
2062 356 compiler_nameop(c, info->fb_datum, Del);
2063 }
2064 3651 return 1;
2065
2066 ✗ case POP_VALUE:
2067 ✗ if (preserve_tos) {
2068 ✗ ADDOP_I(c, SWAP, 2);
2069 }
2070 ✗ ADDOP(c, POP_TOP);
2071 ✗ return 1;
2072 }
2073 ✗ Py_UNREACHABLE();
2074 }
2075
2076 /** Unwind block stack. If loop is not NULL, then stop when the first loop is encountered. */
2077 static int
2078 170245 compiler_unwind_fblock_stack(struct compiler *c, int preserve_tos, struct fblockinfo **loop) {
2079
2/2
✓ Branch 0 taken 150682 times.
✓ Branch 1 taken 19563 times.
 170245 if (c->u->u_nfblocks == 0) {
2080 150682 return 1;
2081 }
2082 19563 struct fblockinfo *top = &c->u->u_fblock[c->u->u_nfblocks-1];
2083
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19563 times.
 19563 if (top->fb_type == EXCEPTION_GROUP_HANDLER) {
2084 ✗ return compiler_error(
2085 c, "'break', 'continue' and 'return' cannot appear in an except* block");
2086 }
2087
6/6
✓ Branch 0 taken 6622 times.
✓ Branch 1 taken 12941 times.
✓ Branch 2 taken 4986 times.
✓ Branch 3 taken 1636 times.
✓ Branch 4 taken 3927 times.
✓ Branch 5 taken 1059 times.
 19563 if (loop != NULL && (top->fb_type == WHILE_LOOP || top->fb_type == FOR_LOOP)) {
2088 5563 *loop = top;
2089 5563 return 1;
2090 }
2091 14000 struct fblockinfo copy = *top;
2092 14000 c->u->u_nfblocks--;
2093
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14000 times.
 14000 if (!compiler_unwind_fblock(c, &copy, preserve_tos)) {
2094 ✗ return 0;
2095 }
2096
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14000 times.
 14000 if (!compiler_unwind_fblock_stack(c, preserve_tos, loop)) {
2097 ✗ return 0;
2098 }
2099 14000 c->u->u_fblock[c->u->u_nfblocks] = copy;
2100 14000 c->u->u_nfblocks++;
2101 14000 return 1;
2102 }
2103
2104 /* Compile a sequence of statements, checking for a docstring
2105 and for annotations. */
2106
2107 static int
2108 55876 compiler_body(struct compiler *c, asdl_stmt_seq *stmts)
2109 {
2110 55876 int i = 0;
2111 stmt_ty st;
2112 PyObject *docstring;
2113
2114 /* Set current line number to the line number of first statement.
2115 This way line number for SETUP_ANNOTATIONS will always
2116 coincide with the line number of first "real" statement in module.
2117 If body is empty, then lineno will be set later in assemble. */
2118
5/6
✓ Branch 0 taken 40672 times.
✓ Branch 1 taken 15204 times.
✓ Branch 2 taken 40383 times.
✓ Branch 3 taken 289 times.
✓ Branch 4 taken 40383 times.
✗ Branch 5 not taken.
 55876 if (c->u->u_scope_type == COMPILER_SCOPE_MODULE && asdl_seq_LEN(stmts)) {
2119 40383 st = (stmt_ty)asdl_seq_GET(stmts, 0);
2120 40383 SET_LOC(c, st);
2121 }
2122 /* Every annotated class and module should have __annotations__. */
2123
2/2
✓ Branch 1 taken 487 times.
✓ Branch 2 taken 55389 times.
 55876 if (find_ann(stmts)) {
2124
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 487 times.
 487 ADDOP(c, SETUP_ANNOTATIONS);
2125 }
2126
3/4
✓ Branch 0 taken 55587 times.
✓ Branch 1 taken 289 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 55587 times.
 55876 if (!asdl_seq_LEN(stmts))
2127 289 return 1;
2128 /* if not -OO mode, set docstring */
2129
1/2
✓ Branch 0 taken 55587 times.
✗ Branch 1 not taken.
 55587 if (c->c_optimize < 2) {
2130 55587 docstring = _PyAST_GetDocString(stmts);
2131
2/2
✓ Branch 0 taken 10742 times.
✓ Branch 1 taken 44845 times.
 55587 if (docstring) {
2132 10742 i = 1;
2133 10742 st = (stmt_ty)asdl_seq_GET(stmts, 0);
2134 assert(st->kind == Expr_kind);
2135
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10742 times.
 10742 VISIT(c, expr, st->v.Expr.value);
2136 10742 UNSET_LOC(c);
2137
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10742 times.
 10742 if (!compiler_nameop(c, &_Py_ID(__doc__), Store))
2138 ✗ return 0;
2139 }
2140 }
2141
3/4
✓ Branch 0 taken 328391 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 272804 times.
✓ Branch 3 taken 55587 times.
 328391 for (; i < asdl_seq_LEN(stmts); i++)
2142
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 272804 times.
 272804 VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i));
2143 55587 return 1;
2144 }
2145
2146 static PyCodeObject *
2147 156685 compiler_mod(struct compiler *c, mod_ty mod)
2148 {
2149 PyCodeObject *co;
2150 156685 int addNone = 1;
2151 _Py_DECLARE_STR(anon_module, "<module>");
2152
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 156685 times.
 156685 if (!compiler_enter_scope(c, &_Py_STR(anon_module), COMPILER_SCOPE_MODULE,
2153 mod, 1)) {
2154 ✗ return NULL;
2155 }
2156 156685 c->u->u_loc.lineno = 1;
2157
2/4
✓ Branch 0 taken 40672 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 116013 times.
✗ Branch 3 not taken.
 156685 switch (mod->kind) {
2158 40672 case Module_kind:
2159
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 40672 times.
 40672 if (!compiler_body(c, mod->v.Module.body)) {
2160 ✗ compiler_exit_scope(c);
2161 ✗ return 0;
2162 }
2163 40672 break;
2164 ✗ case Interactive_kind:
2165 ✗ if (find_ann(mod->v.Interactive.body)) {
2166 ✗ ADDOP(c, SETUP_ANNOTATIONS);
2167 }
2168 ✗ c->c_interactive = 1;
2169 ✗ VISIT_SEQ_IN_SCOPE(c, stmt, mod->v.Interactive.body);
2170 ✗ break;
2171 116013 case Expression_kind:
2172
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 116013 times.
 116013 VISIT_IN_SCOPE(c, expr, mod->v.Expression.body);
2173 116013 addNone = 0;
2174 116013 break;
2175 ✗ default:
2176 ✗ PyErr_Format(PyExc_SystemError,
2177 "module kind %d should not be possible",
2178 ✗ mod->kind);
2179 ✗ return 0;
2180 }
2181 156685 co = assemble(c, addNone);
2182 156685 compiler_exit_scope(c);
2183 156685 return co;
2184 }
2185
2186 /* The test for LOCAL must come before the test for FREE in order to
2187 handle classes where name is both local and free. The local var is
2188 a method and the free var is a free var referenced within a method.
2189 */
2190
2191 static int
2192 27419 get_ref_type(struct compiler *c, PyObject *name)
2193 {
2194 int scope;
2195
4/4
✓ Branch 0 taken 4223 times.
✓ Branch 1 taken 23196 times.
✓ Branch 2 taken 3863 times.
✓ Branch 3 taken 360 times.
 31642 if (c->u->u_scope_type == COMPILER_SCOPE_CLASS &&
2196 4223 _PyUnicode_EqualToASCIIString(name, "__class__"))
2197 3863 return CELL;
2198 23556 scope = _PyST_GetScope(c->u->u_ste, name);
2199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23556 times.
 23556 if (scope == 0) {
2200 ✗ PyErr_Format(PyExc_SystemError,
2201 "_PyST_GetScope(name=%R) failed: "
2202 "unknown scope in unit %S (%R); "
2203 "symbols: %R; locals: %R; globals: %R",
2204 name,
2205 ✗ c->u->u_name, c->u->u_ste->ste_id,
2206 ✗ c->u->u_ste->ste_symbols, c->u->u_varnames, c->u->u_names);
2207 ✗ return -1;
2208 }
2209 23556 return scope;
2210 }
2211
2212 static int
2213 30120 compiler_lookup_arg(PyObject *dict, PyObject *name)
2214 {
2215 PyObject *v;
2216 30120 v = PyDict_GetItemWithError(dict, name);
2217
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30120 times.
 30120 if (v == NULL)
2218 ✗ return -1;
2219 30120 return PyLong_AS_LONG(v);
2220 }
2221
2222 static int
2223 292115 compiler_make_closure(struct compiler *c, PyCodeObject *co, Py_ssize_t flags,
2224 PyObject *qualname)
2225 {
2226
2/2
✓ Branch 0 taken 15204 times.
✓ Branch 1 taken 276911 times.
 292115 if (qualname == NULL)
2227 15204 qualname = co->co_name;
2228
2229
2/2
✓ Branch 0 taken 18367 times.
✓ Branch 1 taken 273748 times.
 292115 if (co->co_nfreevars) {
2230 18367 int i = co->co_nlocals + co->co_nplaincellvars;
2231
2/2
✓ Branch 0 taken 27419 times.
✓ Branch 1 taken 18367 times.
 45786 for (; i < co->co_nlocalsplus; ++i) {
2232 /* Bypass com_addop_varname because it will generate
2233 LOAD_DEREF but LOAD_CLOSURE is needed.
2234 */
2235 27419 PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);
2236
2237 /* Special case: If a class contains a method with a
2238 free variable that has the same name as a method,
2239 the name will be considered free *and* local in the
2240 class. It should be handled by the closure, as
2241 well as by the normal name lookup logic.
2242 */
2243 27419 int reftype = get_ref_type(c, name);
2244
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27419 times.
 27419 if (reftype == -1) {
2245 ✗ return 0;
2246 }
2247 int arg;
2248
2/2
✓ Branch 0 taken 26318 times.
✓ Branch 1 taken 1101 times.
 27419 if (reftype == CELL) {
2249 26318 arg = compiler_lookup_arg(c->u->u_cellvars, name);
2250 }
2251 else {
2252 1101 arg = compiler_lookup_arg(c->u->u_freevars, name);
2253 }
2254
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 27419 times.
 27419 if (arg == -1) {
2255 ✗ PyObject *freevars = _PyCode_GetFreevars(co);
2256 ✗ if (freevars == NULL) {
2257 ✗ PyErr_Clear();
2258 }
2259 ✗ PyErr_Format(PyExc_SystemError,
2260 "compiler_lookup_arg(name=%R) with reftype=%d failed in %S; "
2261 "freevars of code %S: %R",
2262 name,
2263 reftype,
2264 ✗ c->u->u_name,
2265 co->co_name,
2266 freevars);
2267 ✗ Py_DECREF(freevars);
2268 ✗ return 0;
2269 }
2270
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 27419 times.
 27419 ADDOP_I(c, LOAD_CLOSURE, arg);
2271 }
2272 18367 flags |= 0x08;
2273
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 18367 times.
 18367 ADDOP_I(c, BUILD_TUPLE, co->co_nfreevars);
2274 }
2275
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 292115 times.
 292115 ADDOP_LOAD_CONST(c, (PyObject*)co);
2276
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 292115 times.
 292115 ADDOP_I(c, MAKE_FUNCTION, flags);
2277 292115 return 1;
2278 }
2279
2280 static int
2281 175946 compiler_decorators(struct compiler *c, asdl_expr_seq* decos)
2282 {
2283 int i;
2284
2285
2/2
✓ Branch 0 taken 161896 times.
✓ Branch 1 taken 14050 times.
 175946 if (!decos)
2286 161896 return 1;
2287
2288
3/4
✓ Branch 0 taken 28602 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14552 times.
✓ Branch 3 taken 14050 times.
 28602 for (i = 0; i < asdl_seq_LEN(decos); i++) {
2289
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14552 times.
 14552 VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i));
2290 }
2291 14050 return 1;
2292 }
2293
2294 static int
2295 175946 compiler_apply_decorators(struct compiler *c, asdl_expr_seq* decos)
2296 {
2297
2/2
✓ Branch 0 taken 161896 times.
✓ Branch 1 taken 14050 times.
 175946 if (!decos)
2298 161896 return 1;
2299
2300 14050 struct location old_loc = c->u->u_loc;
2301
3/4
✓ Branch 0 taken 14050 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14552 times.
✓ Branch 3 taken 14050 times.
 28602 for (Py_ssize_t i = asdl_seq_LEN(decos) - 1; i > -1; i--) {
2302 14552 SET_LOC(c, (expr_ty)asdl_seq_GET(decos, i));
2303
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14552 times.
 14552 ADDOP_I(c, CALL, 0);
2304 }
2305 14050 c->u->u_loc = old_loc;
2306 14050 return 1;
2307 }
2308
2309 static int
2310 260906 compiler_visit_kwonlydefaults(struct compiler *c, asdl_arg_seq *kwonlyargs,
2311 asdl_expr_seq *kw_defaults)
2312 {
2313 /* Push a dict of keyword-only default values.
2314
2315 Return 0 on error, -1 if no dict pushed, 1 if a dict is pushed.
2316 */
2317 int i;
2318 260906 PyObject *keys = NULL;
2319
2320
3/4
✓ Branch 0 taken 263930 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3024 times.
✓ Branch 3 taken 260906 times.
 263930 for (i = 0; i < asdl_seq_LEN(kwonlyargs); i++) {
2321 3024 arg_ty arg = asdl_seq_GET(kwonlyargs, i);
2322 3024 expr_ty default_ = asdl_seq_GET(kw_defaults, i);
2323
2/2
✓ Branch 0 taken 2872 times.
✓ Branch 1 taken 152 times.
 3024 if (default_) {
2324 2872 PyObject *mangled = _Py_Mangle(c->u->u_private, arg->arg);
2325
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2872 times.
 2872 if (!mangled) {
2326 ✗ goto error;
2327 }
2328
2/2
✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 1850 times.
 2872 if (keys == NULL) {
2329 1022 keys = PyList_New(1);
2330
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1022 times.
 1022 if (keys == NULL) {
2331 ✗ Py_DECREF(mangled);
2332 ✗ return 0;
2333 }
2334 1022 PyList_SET_ITEM(keys, 0, mangled);
2335 }
2336 else {
2337 1850 int res = PyList_Append(keys, mangled);
2338 1850 Py_DECREF(mangled);
2339
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1850 times.
 1850 if (res == -1) {
2340 ✗ goto error;
2341 }
2342 }
2343
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2872 times.
 2872 if (!compiler_visit_expr(c, default_)) {
2344 ✗ goto error;
2345 }
2346 }
2347 }
2348
2/2
✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 259884 times.
 260906 if (keys != NULL) {
2349 1022 Py_ssize_t default_count = PyList_GET_SIZE(keys);
2350 1022 PyObject *keys_tuple = PyList_AsTuple(keys);
2351 1022 Py_DECREF(keys);
2352
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1022 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1022 times.
 1022 ADDOP_LOAD_CONST_NEW(c, keys_tuple);
2353
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1022 times.
 1022 ADDOP_I(c, BUILD_CONST_KEY_MAP, default_count);
2354 assert(default_count > 0);
2355 1022 return 1;
2356 }
2357 else {
2358 259884 return -1;
2359 }
2360
2361 ✗ error:
2362 ✗ Py_XDECREF(keys);
2363 ✗ return 0;
2364 }
2365
2366 static int
2367 877 compiler_visit_annexpr(struct compiler *c, expr_ty annotation)
2368 {
2369
2/4
✗ Branch 1 not taken.
✓ Branch 2 taken 877 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 877 times.
 877 ADDOP_LOAD_CONST_NEW(c, _PyAST_ExprAsUnicode(annotation));
2370 877 return 1;
2371 }
2372
2373 static int
2374 551036 compiler_visit_argannotation(struct compiler *c, identifier id,
2375 expr_ty annotation, Py_ssize_t *annotations_len)
2376 {
2377
2/2
✓ Branch 0 taken 503955 times.
✓ Branch 1 taken 47081 times.
 551036 if (!annotation) {
2378 503955 return 1;
2379 }
2380
2381 47081 PyObject *mangled = _Py_Mangle(c->u->u_private, id);
2382
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 47081 times.
 47081 if (!mangled) {
2383 ✗ return 0;
2384 }
2385
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47081 times.
 47081 ADDOP_LOAD_CONST(c, mangled);
2386 47081 Py_DECREF(mangled);
2387
2388
2/2
✓ Branch 0 taken 873 times.
✓ Branch 1 taken 46208 times.
 47081 if (c->c_future->ff_features & CO_FUTURE_ANNOTATIONS) {
2389
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 873 times.
 873 VISIT(c, annexpr, annotation);
2390 }
2391 else {
2392
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46208 times.
 46208 if (annotation->kind == Starred_kind) {
2393 // *args: *Ts (where Ts is a TypeVarTuple).
2394 // Do [annotation_value] = [*Ts].
2395 // (Note that in theory we could end up here even for an argument
2396 // other than *args, but in practice the grammar doesn't allow it.)
2397 ✗ VISIT(c, expr, annotation->v.Starred.value);
2398 ✗ ADDOP_I(c, UNPACK_SEQUENCE, (Py_ssize_t) 1);
2399 }
2400 else {
2401
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 46208 times.
 46208 VISIT(c, expr, annotation);
2402 }
2403 }
2404 47081 *annotations_len += 2;
2405 47081 return 1;
2406 }
2407
2408 static int
2409 482226 compiler_visit_argannotations(struct compiler *c, asdl_arg_seq* args,
2410 Py_ssize_t *annotations_len)
2411 {
2412 int i;
2413
3/4
✓ Branch 0 taken 872072 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 389846 times.
✓ Branch 3 taken 482226 times.
 872072 for (i = 0; i < asdl_seq_LEN(args); i++) {
2414 389846 arg_ty arg = (arg_ty)asdl_seq_GET(args, i);
2415
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 389846 times.
 389846 if (!compiler_visit_argannotation(
2416 c,
2417 arg->arg,
2418 arg->annotation,
2419 annotations_len))
2420 ✗ return 0;
2421 }
2422 482226 return 1;
2423 }
2424
2425 static int
2426 160742 compiler_visit_annotations(struct compiler *c, arguments_ty args,
2427 expr_ty returns)
2428 {
2429 /* Push arg annotation names and values.
2430 The expressions are evaluated out-of-order wrt the source code.
2431
2432 Return 0 on error, -1 if no annotations pushed, 1 if a annotations is pushed.
2433 */
2434 160742 Py_ssize_t annotations_len = 0;
2435
2436
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_visit_argannotations(c, args->args, &annotations_len))
2437 ✗ return 0;
2438
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_visit_argannotations(c, args->posonlyargs, &annotations_len))
2439 ✗ return 0;
2440
5/6
✓ Branch 0 taken 7246 times.
✓ Branch 1 taken 153496 times.
✓ Branch 2 taken 243 times.
✓ Branch 3 taken 7003 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 243 times.
 160985 if (args->vararg && args->vararg->annotation &&
2441 243 !compiler_visit_argannotation(c, args->vararg->arg,
2442 243 args->vararg->annotation, &annotations_len))
2443 ✗ return 0;
2444
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_visit_argannotations(c, args->kwonlyargs, &annotations_len))
2445 ✗ return 0;
2446
5/6
✓ Branch 0 taken 9906 times.
✓ Branch 1 taken 150836 times.
✓ Branch 2 taken 205 times.
✓ Branch 3 taken 9701 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 205 times.
 160947 if (args->kwarg && args->kwarg->annotation &&
2447 205 !compiler_visit_argannotation(c, args->kwarg->arg,
2448 205 args->kwarg->annotation, &annotations_len))
2449 ✗ return 0;
2450
2451
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_visit_argannotation(c, &_Py_ID(return), returns,
2452 &annotations_len)) {
2453 ✗ return 0;
2454 }
2455
2456
2/2
✓ Branch 0 taken 13673 times.
✓ Branch 1 taken 147069 times.
 160742 if (annotations_len) {
2457
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13673 times.
 13673 ADDOP_I(c, BUILD_TUPLE, annotations_len);
2458 13673 return 1;
2459 }
2460
2461 147069 return -1;
2462 }
2463
2464 static int
2465 20527 compiler_visit_defaults(struct compiler *c, arguments_ty args)
2466 {
2467
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 53035 times.
✓ Branch 3 taken 73562 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 53035 times.
✓ Branch 6 taken 20527 times.
 73562 VISIT_SEQ(c, expr, args->defaults);
2468
2/4
✓ Branch 0 taken 20527 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 20527 times.
 20527 ADDOP_I(c, BUILD_TUPLE, asdl_seq_LEN(args->defaults));
2469 20527 return 1;
2470 }
2471
2472 static Py_ssize_t
2473 260906 compiler_default_arguments(struct compiler *c, arguments_ty args)
2474 {
2475 260906 Py_ssize_t funcflags = 0;
2476
4/6
✓ Branch 0 taken 260906 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 260906 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 20527 times.
✓ Branch 5 taken 240379 times.
 260906 if (args->defaults && asdl_seq_LEN(args->defaults) > 0) {
2477
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20527 times.
 20527 if (!compiler_visit_defaults(c, args))
2478 ✗ return -1;
2479 20527 funcflags |= 0x01;
2480 }
2481
1/2
✓ Branch 0 taken 260906 times.
✗ Branch 1 not taken.
 260906 if (args->kwonlyargs) {
2482 260906 int res = compiler_visit_kwonlydefaults(c, args->kwonlyargs,
2483 args->kw_defaults);
2484
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 260906 times.
 260906 if (res == 0) {
2485 ✗ return -1;
2486 }
2487
2/2
✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 259884 times.
 260906 else if (res > 0) {
2488 1022 funcflags |= 0x02;
2489 }
2490 }
2491 260906 return funcflags;
2492 }
2493
2494 static int
2495 6395660 forbidden_name(struct compiler *c, identifier name, expr_context_ty ctx)
2496 {
2497
2498
3/4
✓ Branch 0 taken 2073709 times.
✓ Branch 1 taken 4321951 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2073709 times.
 6395660 if (ctx == Store && _PyUnicode_EqualToASCIIString(name, "__debug__")) {
2499 ✗ compiler_error(c, "cannot assign to __debug__");
2500 ✗ return 1;
2501 }
2502
3/4
✓ Branch 0 taken 4894 times.
✓ Branch 1 taken 6390766 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4894 times.
 6395660 if (ctx == Del && _PyUnicode_EqualToASCIIString(name, "__debug__")) {
2503 ✗ compiler_error(c, "cannot delete __debug__");
2504 ✗ return 1;
2505 }
2506 6395660 return 0;
2507 }
2508
2509 static int
2510 1462448 compiler_check_debug_one_arg(struct compiler *c, arg_ty arg)
2511 {
2512
2/2
✓ Branch 0 taken 957925 times.
✓ Branch 1 taken 504523 times.
 1462448 if (arg != NULL) {
2513
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 957925 times.
 957925 if (forbidden_name(c, arg->arg, Store))
2514 ✗ return 0;
2515 }
2516 1462448 return 1;
2517 }
2518
2519 static int
2520 782718 compiler_check_debug_args_seq(struct compiler *c, asdl_arg_seq *args)
2521 {
2522
1/2
✓ Branch 0 taken 782718 times.
✗ Branch 1 not taken.
 782718 if (args != NULL) {
2523
3/4
✓ Branch 0 taken 782718 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 940636 times.
✓ Branch 3 taken 782718 times.
 1723354 for (Py_ssize_t i = 0, n = asdl_seq_LEN(args); i < n; i++) {
2524
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 940636 times.
 940636 if (!compiler_check_debug_one_arg(c, asdl_seq_GET(args, i)))
2525 ✗ return 0;
2526 }
2527 }
2528 782718 return 1;
2529 }
2530
2531 static int
2532 260906 compiler_check_debug_args(struct compiler *c, arguments_ty args)
2533 {
2534
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 260906 times.
 260906 if (!compiler_check_debug_args_seq(c, args->posonlyargs))
2535 ✗ return 0;
2536
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 260906 times.
 260906 if (!compiler_check_debug_args_seq(c, args->args))
2537 ✗ return 0;
2538
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 260906 times.
 260906 if (!compiler_check_debug_one_arg(c, args->vararg))
2539 ✗ return 0;
2540
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 260906 times.
 260906 if (!compiler_check_debug_args_seq(c, args->kwonlyargs))
2541 ✗ return 0;
2542
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 260906 times.
 260906 if (!compiler_check_debug_one_arg(c, args->kwarg))
2543 ✗ return 0;
2544 260906 return 1;
2545 }
2546
2547 static int
2548 160742 compiler_function(struct compiler *c, stmt_ty s, int is_async)
2549 {
2550 PyCodeObject *co;
2551 160742 PyObject *qualname, *docstring = NULL;
2552 arguments_ty args;
2553 expr_ty returns;
2554 identifier name;
2555 asdl_expr_seq* decos;
2556 asdl_stmt_seq *body;
2557 Py_ssize_t i, funcflags;
2558 int annotations;
2559 int scope_type;
2560 int firstlineno;
2561
2562
2/2
✓ Branch 0 taken 1106 times.
✓ Branch 1 taken 159636 times.
 160742 if (is_async) {
2563 assert(s->kind == AsyncFunctionDef_kind);
2564
2565 1106 args = s->v.AsyncFunctionDef.args;
2566 1106 returns = s->v.AsyncFunctionDef.returns;
2567 1106 decos = s->v.AsyncFunctionDef.decorator_list;
2568 1106 name = s->v.AsyncFunctionDef.name;
2569 1106 body = s->v.AsyncFunctionDef.body;
2570
2571 1106 scope_type = COMPILER_SCOPE_ASYNC_FUNCTION;
2572 } else {
2573 assert(s->kind == FunctionDef_kind);
2574
2575 159636 args = s->v.FunctionDef.args;
2576 159636 returns = s->v.FunctionDef.returns;
2577 159636 decos = s->v.FunctionDef.decorator_list;
2578 159636 name = s->v.FunctionDef.name;
2579 159636 body = s->v.FunctionDef.body;
2580
2581 159636 scope_type = COMPILER_SCOPE_FUNCTION;
2582 }
2583
2584
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_check_debug_args(c, args))
2585 ✗ return 0;
2586
2587
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_decorators(c, decos))
2588 ✗ return 0;
2589
2590 160742 firstlineno = s->lineno;
2591
3/4
✓ Branch 0 taken 13563 times.
✓ Branch 1 taken 147179 times.
✓ Branch 2 taken 13563 times.
✗ Branch 3 not taken.
 160742 if (asdl_seq_LEN(decos)) {
2592 13563 firstlineno = ((expr_ty)asdl_seq_GET(decos, 0))->lineno;
2593 }
2594
2595 160742 funcflags = compiler_default_arguments(c, args);
2596
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 160742 times.
 160742 if (funcflags == -1) {
2597 ✗ return 0;
2598 }
2599
2600 160742 annotations = compiler_visit_annotations(c, args, returns);
2601
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 160742 times.
 160742 if (annotations == 0) {
2602 ✗ return 0;
2603 }
2604
2/2
✓ Branch 0 taken 13673 times.
✓ Branch 1 taken 147069 times.
 160742 else if (annotations > 0) {
2605 13673 funcflags |= 0x04;
2606 }
2607
2608
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_enter_scope(c, name, scope_type, (void *)s, firstlineno)) {
2609 ✗ return 0;
2610 }
2611
2612 /* if not -OO mode, add docstring */
2613
1/2
✓ Branch 0 taken 160742 times.
✗ Branch 1 not taken.
 160742 if (c->c_optimize < 2) {
2614 160742 docstring = _PyAST_GetDocString(body);
2615 }
2616
3/4
✓ Branch 0 taken 29645 times.
✓ Branch 1 taken 131097 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160742 times.
 160742 if (compiler_add_const(c, docstring ? docstring : Py_None) < 0) {
2617 ✗ compiler_exit_scope(c);
2618 ✗ return 0;
2619 }
2620
2621
1/2
✓ Branch 0 taken 160742 times.
✗ Branch 1 not taken.
 160742 c->u->u_argcount = asdl_seq_LEN(args->args);
2622
1/2
✓ Branch 0 taken 160742 times.
✗ Branch 1 not taken.
 160742 c->u->u_posonlyargcount = asdl_seq_LEN(args->posonlyargs);
2623
1/2
✓ Branch 0 taken 160742 times.
✗ Branch 1 not taken.
 160742 c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs);
2624
3/4
✓ Branch 0 taken 706240 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 545498 times.
✓ Branch 3 taken 160742 times.
 706240 for (i = docstring ? 1 : 0; i < asdl_seq_LEN(body); i++) {
2625
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 545498 times.
 545498 VISIT_IN_SCOPE(c, stmt, (stmt_ty)asdl_seq_GET(body, i));
2626 }
2627 160742 co = assemble(c, 1);
2628 160742 qualname = c->u->u_qualname;
2629 160742 Py_INCREF(qualname);
2630 160742 compiler_exit_scope(c);
2631
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 160742 times.
 160742 if (co == NULL) {
2632 ✗ Py_XDECREF(qualname);
2633 ✗ Py_XDECREF(co);
2634 ✗ return 0;
2635 }
2636
2637
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_make_closure(c, co, funcflags, qualname)) {
2638 ✗ Py_DECREF(qualname);
2639 ✗ Py_DECREF(co);
2640 ✗ return 0;
2641 }
2642 160742 Py_DECREF(qualname);
2643 160742 Py_DECREF(co);
2644
2645
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160742 times.
 160742 if (!compiler_apply_decorators(c, decos))
2646 ✗ return 0;
2647 160742 return compiler_nameop(c, name, Store);
2648 }
2649
2650 static int
2651 15204 compiler_class(struct compiler *c, stmt_ty s)
2652 {
2653 PyCodeObject *co;
2654 int i, firstlineno;
2655 15204 asdl_expr_seq *decos = s->v.ClassDef.decorator_list;
2656
2657
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_decorators(c, decos))
2658 ✗ return 0;
2659
2660 15204 firstlineno = s->lineno;
2661
3/4
✓ Branch 0 taken 487 times.
✓ Branch 1 taken 14717 times.
✓ Branch 2 taken 487 times.
✗ Branch 3 not taken.
 15204 if (asdl_seq_LEN(decos)) {
2662 487 firstlineno = ((expr_ty)asdl_seq_GET(decos, 0))->lineno;
2663 }
2664
2665 /* ultimately generate code for:
2666 <name> = __build_class__(<func>, <name>, *<bases>, **<keywords>)
2667 where:
2668 <func> is a zero arg function/closure created from the class body.
2669 It mutates its locals to build the class namespace.
2670 <name> is the class name
2671 <bases> is the positional arguments and *varargs argument
2672 <keywords> is the keyword arguments and **kwds argument
2673 This borrows from compiler_call.
2674 */
2675
2676 /* 1. compile the class body into a code object */
2677
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_enter_scope(c, s->v.ClassDef.name,
2678 COMPILER_SCOPE_CLASS, (void *)s, firstlineno)) {
2679 ✗ return 0;
2680 }
2681 /* this block represents what we do in the new scope */
2682 {
2683 /* use the class name for name mangling */
2684 15204 Py_INCREF(s->v.ClassDef.name);
2685 15204 Py_XSETREF(c->u->u_private, s->v.ClassDef.name);
2686 /* load (global) __name__ ... */
2687
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_nameop(c, &_Py_ID(__name__), Load)) {
2688 ✗ compiler_exit_scope(c);
2689 ✗ return 0;
2690 }
2691 /* ... and store it as __module__ */
2692
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_nameop(c, &_Py_ID(__module__), Store)) {
2693 ✗ compiler_exit_scope(c);
2694 ✗ return 0;
2695 }
2696 assert(c->u->u_qualname);
2697
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 ADDOP_LOAD_CONST(c, c->u->u_qualname);
2698
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_nameop(c, &_Py_ID(__qualname__), Store)) {
2699 ✗ compiler_exit_scope(c);
2700 ✗ return 0;
2701 }
2702 /* compile the body proper */
2703
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_body(c, s->v.ClassDef.body)) {
2704 ✗ compiler_exit_scope(c);
2705 ✗ return 0;
2706 }
2707 /* The following code is artificial */
2708 15204 UNSET_LOC(c);
2709 /* Return __classcell__ if it is referenced, otherwise return None */
2710
2/2
✓ Branch 0 taken 2701 times.
✓ Branch 1 taken 12503 times.
 15204 if (c->u->u_ste->ste_needs_class_closure) {
2711 /* Store __classcell__ into class namespace & return it */
2712 2701 i = compiler_lookup_arg(c->u->u_cellvars, &_Py_ID(__class__));
2713
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2701 times.
 2701 if (i < 0) {
2714 ✗ compiler_exit_scope(c);
2715 ✗ return 0;
2716 }
2717 assert(i == 0);
2718
2719
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2701 times.
 2701 ADDOP_I(c, LOAD_CLOSURE, i);
2720
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2701 times.
 2701 ADDOP_I(c, COPY, 1);
2721
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2701 times.
 2701 if (!compiler_nameop(c, &_Py_ID(__classcell__), Store)) {
2722 ✗ compiler_exit_scope(c);
2723 ✗ return 0;
2724 }
2725 }
2726 else {
2727 /* No methods referenced __class__, so just return None */
2728 assert(PyDict_GET_SIZE(c->u->u_cellvars) == 0);
2729
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12503 times.
 12503 ADDOP_LOAD_CONST(c, Py_None);
2730 }
2731
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 ADDOP_IN_SCOPE(c, RETURN_VALUE);
2732 /* create the code object */
2733 15204 co = assemble(c, 1);
2734 }
2735 /* leave the new scope */
2736 15204 compiler_exit_scope(c);
2737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15204 times.
 15204 if (co == NULL)
2738 ✗ return 0;
2739
2740 /* 2. load the 'build_class' function */
2741
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 ADDOP(c, PUSH_NULL);
2742
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 ADDOP(c, LOAD_BUILD_CLASS);
2743
2744 /* 3. load a function (or closure) made from the code object */
2745
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_make_closure(c, co, 0, NULL)) {
2746 ✗ Py_DECREF(co);
2747 ✗ return 0;
2748 }
2749 15204 Py_DECREF(co);
2750
2751 /* 4. load class name */
2752
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 ADDOP_LOAD_CONST(c, s->v.ClassDef.name);
2753
2754 /* 5. generate the rest of the code for the call */
2755
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_call_helper(c, 2, s->v.ClassDef.bases, s->v.ClassDef.keywords))
2756 ✗ return 0;
2757 /* 6. apply decorators */
2758
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_apply_decorators(c, decos))
2759 ✗ return 0;
2760
2761 /* 7. store into <name> */
2762
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15204 times.
 15204 if (!compiler_nameop(c, s->v.ClassDef.name, Store))
2763 ✗ return 0;
2764 15204 return 1;
2765 }
2766
2767 /* Return 0 if the expression is a constant value except named singletons.
2768 Return 1 otherwise. */
2769 static int
2770 344853 check_is_arg(expr_ty e)
2771 {
2772
2/2
✓ Branch 0 taken 257103 times.
✓ Branch 1 taken 87750 times.
 344853 if (e->kind != Constant_kind) {
2773 257103 return 1;
2774 }
2775 87750 PyObject *value = e->v.Constant.value;
2776 return (value == Py_None
2777
2/2
✓ Branch 0 taken 63356 times.
✓ Branch 1 taken 3272 times.
 66628 || value == Py_False
2778
2/2
✓ Branch 0 taken 60353 times.
✓ Branch 1 taken 3003 times.
 63356 || value == Py_True
2779
4/4
✓ Branch 0 taken 66628 times.
✓ Branch 1 taken 21122 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 60339 times.
 154378 || value == Py_Ellipsis);
2780 }
2781
2782 /* Check operands of identity chacks ("is" and "is not").
2783 Emit a warning if any operand is a constant except named singletons.
2784 Return 0 on error.
2785 */
2786 static int
2787 171329 check_compare(struct compiler *c, expr_ty e)
2788 {
2789 Py_ssize_t i, n;
2790 171329 int left = check_is_arg(e->v.Compare.left);
2791
1/2
✓ Branch 0 taken 171329 times.
✗ Branch 1 not taken.
 171329 n = asdl_seq_LEN(e->v.Compare.ops);
2792
2/2
✓ Branch 0 taken 173524 times.
✓ Branch 1 taken 171329 times.
 344853 for (i = 0; i < n; i++) {
2793 173524 cmpop_ty op = (cmpop_ty)asdl_seq_GET(e->v.Compare.ops, i);
2794 173524 int right = check_is_arg((expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
2795
4/4
✓ Branch 0 taken 147797 times.
✓ Branch 1 taken 25727 times.
✓ Branch 2 taken 11709 times.
✓ Branch 3 taken 136088 times.
 173524 if (op == Is || op == IsNot) {
2796
2/4
✓ Branch 0 taken 37436 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 37436 times.
 37436 if (!right || !left) {
2797 ✗ const char *msg = (op == Is)
2798 ? "\"is\" with a literal. Did you mean \"==\"?"
2799 ✗ : "\"is not\" with a literal. Did you mean \"!=\"?";
2800 ✗ return compiler_warn(c, msg);
2801 }
2802 }
2803 173524 left = right;
2804 }
2805 171329 return 1;
2806 }
2807
2808 173525 static int compiler_addcompare(struct compiler *c, cmpop_ty op)
2809 {
2810 int cmp;
2811
10/11
✓ Branch 0 taken 86862 times.
✓ Branch 1 taken 9733 times.
✓ Branch 2 taken 9477 times.
✓ Branch 3 taken 4497 times.
✓ Branch 4 taken 6711 times.
✓ Branch 5 taken 3194 times.
✓ Branch 6 taken 25728 times.
✓ Branch 7 taken 11709 times.
✓ Branch 8 taken 11316 times.
✓ Branch 9 taken 4298 times.
✗ Branch 10 not taken.
 173525 switch (op) {
2812 86862 case Eq:
2813 86862 cmp = Py_EQ;
2814 86862 break;
2815 9733 case NotEq:
2816 9733 cmp = Py_NE;
2817 9733 break;
2818 9477 case Lt:
2819 9477 cmp = Py_LT;
2820 9477 break;
2821 4497 case LtE:
2822 4497 cmp = Py_LE;
2823 4497 break;
2824 6711 case Gt:
2825 6711 cmp = Py_GT;
2826 6711 break;
2827 3194 case GtE:
2828 3194 cmp = Py_GE;
2829 3194 break;
2830 25728 case Is:
2831
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 25728 times.
 25728 ADDOP_I(c, IS_OP, 0);
2832 25728 return 1;
2833 11709 case IsNot:
2834
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11709 times.
 11709 ADDOP_I(c, IS_OP, 1);
2835 11709 return 1;
2836 11316 case In:
2837
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11316 times.
 11316 ADDOP_I(c, CONTAINS_OP, 0);
2838 11316 return 1;
2839 4298 case NotIn:
2840
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4298 times.
 4298 ADDOP_I(c, CONTAINS_OP, 1);
2841 4298 return 1;
2842 ✗ default:
2843 ✗ Py_UNREACHABLE();
2844 }
2845
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 120474 times.
 120474 ADDOP_I(c, COMPARE_OP, cmp);
2846 120474 return 1;
2847 }
2848
2849
2850
2851 static int
2852 294229 compiler_jump_if(struct compiler *c, expr_ty e, basicblock *next, int cond)
2853 {
2854
5/5
✓ Branch 0 taken 20533 times.
✓ Branch 1 taken 19747 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 150213 times.
✓ Branch 4 taken 103727 times.
 294229 switch (e->kind) {
2855 20533 case UnaryOp_kind:
2856
2/2
✓ Branch 0 taken 20531 times.
✓ Branch 1 taken 2 times.
 20533 if (e->v.UnaryOp.op == Not)
2857 20531 return compiler_jump_if(c, e->v.UnaryOp.operand, next, !cond);
2858 /* fallback to general implementation */
2859 2 break;
2860 19747 case BoolOp_kind: {
2861 19747 asdl_expr_seq *s = e->v.BoolOp.values;
2862
1/2
✓ Branch 0 taken 19747 times.
✗ Branch 1 not taken.
 19747 Py_ssize_t i, n = asdl_seq_LEN(s) - 1;
2863 assert(n >= 0);
2864 19747 int cond2 = e->v.BoolOp.op == Or;
2865 19747 basicblock *next2 = next;
2866
2/2
✓ Branch 0 taken 6689 times.
✓ Branch 1 taken 13058 times.
 19747 if (!cond2 != !cond) {
2867 6689 next2 = compiler_new_block(c);
2868
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6689 times.
 6689 if (next2 == NULL)
2869 ✗ return 0;
2870 }
2871
2/2
✓ Branch 0 taken 22518 times.
✓ Branch 1 taken 19747 times.
 42265 for (i = 0; i < n; ++i) {
2872
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22518 times.
 22518 if (!compiler_jump_if(c, (expr_ty)asdl_seq_GET(s, i), next2, cond2))
2873 ✗ return 0;
2874 }
2875
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19747 times.
 19747 if (!compiler_jump_if(c, (expr_ty)asdl_seq_GET(s, n), next, cond))
2876 ✗ return 0;
2877
2/2
✓ Branch 0 taken 6689 times.
✓ Branch 1 taken 13058 times.
 19747 if (next2 != next)
2878 6689 compiler_use_next_block(c, next2);
2879 19747 return 1;
2880 }
2881 9 case IfExp_kind: {
2882 basicblock *end, *next2;
2883 9 end = compiler_new_block(c);
2884
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (end == NULL)
2885 ✗ return 0;
2886 9 next2 = compiler_new_block(c);
2887
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (next2 == NULL)
2888 ✗ return 0;
2889
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 9 if (!compiler_jump_if(c, e->v.IfExp.test, next2, 0))
2890 ✗ return 0;
2891
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 9 if (!compiler_jump_if(c, e->v.IfExp.body, next, cond))
2892 ✗ return 0;
2893
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 9 ADDOP_JUMP_NOLINE(c, JUMP, end);
2894 9 compiler_use_next_block(c, next2);
2895
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 9 if (!compiler_jump_if(c, e->v.IfExp.orelse, next, cond))
2896 ✗ return 0;
2897 9 compiler_use_next_block(c, end);
2898 9 return 1;
2899 }
2900 150213 case Compare_kind: {
2901
1/2
✓ Branch 0 taken 150213 times.
✗ Branch 1 not taken.
 150213 Py_ssize_t i, n = asdl_seq_LEN(e->v.Compare.ops) - 1;
2902
2/2
✓ Branch 0 taken 1961 times.
✓ Branch 1 taken 148252 times.
 150213 if (n > 0) {
2903
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1961 times.
 1961 if (!check_compare(c, e)) {
2904 ✗ return 0;
2905 }
2906 1961 basicblock *cleanup = compiler_new_block(c);
2907
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1961 times.
 1961 if (cleanup == NULL)
2908 ✗ return 0;
2909
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1961 times.
 1961 VISIT(c, expr, e->v.Compare.left);
2910
2/2
✓ Branch 0 taken 2123 times.
✓ Branch 1 taken 1961 times.
 4084 for (i = 0; i < n; i++) {
2911
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2123 times.
 2123 VISIT(c, expr,
2912 (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
2913
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2123 times.
 2123 ADDOP_I(c, SWAP, 2);
2914
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2123 times.
 2123 ADDOP_I(c, COPY, 2);
2915
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2123 times.
 2123 ADDOP_COMPARE(c, asdl_seq_GET(e->v.Compare.ops, i));
2916
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2123 times.
 2123 ADDOP_JUMP(c, POP_JUMP_IF_FALSE, cleanup);
2917 }
2918
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1961 times.
 1961 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n));
2919
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1961 times.
 1961 ADDOP_COMPARE(c, asdl_seq_GET(e->v.Compare.ops, n));
2920
3/4
✓ Branch 0 taken 1017 times.
✓ Branch 1 taken 944 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1961 times.
 1961 ADDOP_JUMP(c, cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next);
2921 1961 basicblock *end = compiler_new_block(c);
2922
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1961 times.
 1961 if (end == NULL)
2923 ✗ return 0;
2924
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1961 times.
 1961 ADDOP_JUMP_NOLINE(c, JUMP, end);
2925 1961 compiler_use_next_block(c, cleanup);
2926
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1961 times.
 1961 ADDOP(c, POP_TOP);
2927
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 1017 times.
 1961 if (!cond) {
2928
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 944 times.
 944 ADDOP_JUMP_NOLINE(c, JUMP, next);
2929 }
2930 1961 compiler_use_next_block(c, end);
2931 1961 return 1;
2932 }
2933 /* fallback to general implementation */
2934 148252 break;
2935 }
2936 103727 default:
2937 /* fallback to general implementation */
2938 103727 break;
2939 }
2940
2941 /* general implementation */
2942
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 251981 times.
 251981 VISIT(c, expr, e);
2943
3/4
✓ Branch 0 taken 103727 times.
✓ Branch 1 taken 148254 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 251981 times.
 251981 ADDOP_JUMP(c, cond ? POP_JUMP_IF_TRUE : POP_JUMP_IF_FALSE, next);
2944 251981 return 1;
2945 }
2946
2947 static int
2948 5964 compiler_ifexp(struct compiler *c, expr_ty e)
2949 {
2950 basicblock *end, *next;
2951
2952 assert(e->kind == IfExp_kind);
2953 5964 end = compiler_new_block(c);
2954
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5964 times.
 5964 if (end == NULL)
2955 ✗ return 0;
2956 5964 next = compiler_new_block(c);
2957
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5964 times.
 5964 if (next == NULL)
2958 ✗ return 0;
2959
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5964 times.
 5964 if (!compiler_jump_if(c, e->v.IfExp.test, next, 0))
2960 ✗ return 0;
2961
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5964 times.
 5964 VISIT(c, expr, e->v.IfExp.body);
2962
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5964 times.
 5964 ADDOP_JUMP_NOLINE(c, JUMP, end);
2963 5964 compiler_use_next_block(c, next);
2964
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5964 times.
 5964 VISIT(c, expr, e->v.IfExp.orelse);
2965 5964 compiler_use_next_block(c, end);
2966 5964 return 1;
2967 }
2968
2969 static int
2970 100164 compiler_lambda(struct compiler *c, expr_ty e)
2971 {
2972 PyCodeObject *co;
2973 PyObject *qualname;
2974 Py_ssize_t funcflags;
2975 100164 arguments_ty args = e->v.Lambda.args;
2976 assert(e->kind == Lambda_kind);
2977
2978
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 100164 times.
 100164 if (!compiler_check_debug_args(c, args))
2979 ✗ return 0;
2980
2981 100164 funcflags = compiler_default_arguments(c, args);
2982
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100164 times.
 100164 if (funcflags == -1) {
2983 ✗ return 0;
2984 }
2985
2986 _Py_DECLARE_STR(anon_lambda, "<lambda>");
2987
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 100164 times.
 100164 if (!compiler_enter_scope(c, &_Py_STR(anon_lambda), COMPILER_SCOPE_LAMBDA,
2988 (void *)e, e->lineno)) {
2989 ✗ return 0;
2990 }
2991 /* Make None the first constant, so the lambda can't have a
2992 docstring. */
2993
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 100164 times.
 100164 if (compiler_add_const(c, Py_None) < 0)
2994 ✗ return 0;
2995
2996
1/2
✓ Branch 0 taken 100164 times.
✗ Branch 1 not taken.
 100164 c->u->u_argcount = asdl_seq_LEN(args->args);
2997
1/2
✓ Branch 0 taken 100164 times.
✗ Branch 1 not taken.
 100164 c->u->u_posonlyargcount = asdl_seq_LEN(args->posonlyargs);
2998
1/2
✓ Branch 0 taken 100164 times.
✗ Branch 1 not taken.
 100164 c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs);
2999
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 100164 times.
 100164 VISIT_IN_SCOPE(c, expr, e->v.Lambda.body);
3000
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 100160 times.
 100164 if (c->u->u_ste->ste_generator) {
3001 4 co = assemble(c, 0);
3002 }
3003 else {
3004
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 100160 times.
 100160 ADDOP_IN_SCOPE(c, RETURN_VALUE);
3005 100160 co = assemble(c, 1);
3006 }
3007 100164 qualname = c->u->u_qualname;
3008 100164 Py_INCREF(qualname);
3009 100164 compiler_exit_scope(c);
3010
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100164 times.
 100164 if (co == NULL) {
3011 ✗ Py_DECREF(qualname);
3012 ✗ return 0;
3013 }
3014
3015
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 100164 times.
 100164 if (!compiler_make_closure(c, co, funcflags, qualname)) {
3016 ✗ Py_DECREF(qualname);
3017 ✗ Py_DECREF(co);
3018 ✗ return 0;
3019 }
3020 100164 Py_DECREF(qualname);
3021 100164 Py_DECREF(co);
3022
3023 100164 return 1;
3024 }
3025
3026 static int
3027 137065 compiler_if(struct compiler *c, stmt_ty s)
3028 {
3029 basicblock *end, *next;
3030 assert(s->kind == If_kind);
3031 137065 end = compiler_new_block(c);
3032
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 137065 times.
 137065 if (end == NULL) {
3033 ✗ return 0;
3034 }
3035
3/4
✓ Branch 0 taken 41953 times.
✓ Branch 1 taken 95112 times.
✓ Branch 2 taken 41953 times.
✗ Branch 3 not taken.
 137065 if (asdl_seq_LEN(s->v.If.orelse)) {
3036 41953 next = compiler_new_block(c);
3037
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41953 times.
 41953 if (next == NULL) {
3038 ✗ return 0;
3039 }
3040 }
3041 else {
3042 95112 next = end;
3043 }
3044
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 137065 times.
 137065 if (!compiler_jump_if(c, s->v.If.test, next, 0)) {
3045 ✗ return 0;
3046 }
3047
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 223134 times.
✓ Branch 3 taken 360199 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 223134 times.
✓ Branch 6 taken 137065 times.
 360199 VISIT_SEQ(c, stmt, s->v.If.body);
3048
3/4
✓ Branch 0 taken 41953 times.
✓ Branch 1 taken 95112 times.
✓ Branch 2 taken 41953 times.
✗ Branch 3 not taken.
 137065 if (asdl_seq_LEN(s->v.If.orelse)) {
3049
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 41953 times.
 41953 ADDOP_JUMP_NOLINE(c, JUMP, end);
3050 41953 compiler_use_next_block(c, next);
3051
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 54901 times.
✓ Branch 3 taken 96854 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 54901 times.
✓ Branch 6 taken 41953 times.
 96854 VISIT_SEQ(c, stmt, s->v.If.orelse);
3052 }
3053 137065 compiler_use_next_block(c, end);
3054 137065 return 1;
3055 }
3056
3057 static int
3058 33890 compiler_for(struct compiler *c, stmt_ty s)
3059 {
3060 basicblock *start, *body, *cleanup, *end;
3061
3062 33890 start = compiler_new_block(c);
3063 33890 body = compiler_new_block(c);
3064 33890 cleanup = compiler_new_block(c);
3065 33890 end = compiler_new_block(c);
3066
4/8
✓ Branch 0 taken 33890 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33890 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 33890 times.
 33890 if (start == NULL || body == NULL || end == NULL || cleanup == NULL) {
3067 ✗ return 0;
3068 }
3069
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
 33890 if (!compiler_push_fblock(c, FOR_LOOP, start, end, NULL)) {
3070 ✗ return 0;
3071 }
3072
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
 33890 VISIT(c, expr, s->v.For.iter);
3073
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
 33890 ADDOP(c, GET_ITER);
3074 33890 compiler_use_next_block(c, start);
3075
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
 33890 ADDOP_JUMP(c, FOR_ITER, cleanup);
3076 33890 compiler_use_next_block(c, body);
3077
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
 33890 VISIT(c, expr, s->v.For.target);
3078
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 121639 times.
✓ Branch 3 taken 155529 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 121639 times.
✓ Branch 6 taken 33890 times.
 155529 VISIT_SEQ(c, stmt, s->v.For.body);
3079 /* Mark jump as artificial */
3080 33890 UNSET_LOC(c);
3081
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33890 times.
 33890 ADDOP_JUMP(c, JUMP, start);
3082 33890 compiler_use_next_block(c, cleanup);
3083
3084 33890 compiler_pop_fblock(c, FOR_LOOP, start);
3085
3086
5/6
✗ Branch 1 not taken.
✓ Branch 2 taken 659 times.
✓ Branch 3 taken 1158 times.
✓ Branch 4 taken 33391 times.
✓ Branch 5 taken 659 times.
✓ Branch 6 taken 33890 times.
 34549 VISIT_SEQ(c, stmt, s->v.For.orelse);
3087 33890 compiler_use_next_block(c, end);
3088 33890 return 1;
3089 }
3090
3091
3092 static int
3093 3 compiler_async_for(struct compiler *c, stmt_ty s)
3094 {
3095 basicblock *start, *except, *end;
3096
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 3 if (IS_TOP_LEVEL_AWAIT(c)){
3097 ✗ c->u->u_ste->ste_coroutine = 1;
3098
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 } else if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION) {
3099 ✗ return compiler_error(c, "'async for' outside async function");
3100 }
3101
3102 3 start = compiler_new_block(c);
3103 3 except = compiler_new_block(c);
3104 3 end = compiler_new_block(c);
3105
3106
3/6
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
 3 if (start == NULL || except == NULL || end == NULL) {
3107 ✗ return 0;
3108 }
3109
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 VISIT(c, expr, s->v.AsyncFor.iter);
3110
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP(c, GET_AITER);
3111
3112 3 compiler_use_next_block(c, start);
3113
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (!compiler_push_fblock(c, FOR_LOOP, start, end, NULL)) {
3114 ✗ return 0;
3115 }
3116 /* SETUP_FINALLY to guard the __anext__ call */
3117
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP_JUMP(c, SETUP_FINALLY, except);
3118
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP(c, GET_ANEXT);
3119
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP_LOAD_CONST(c, Py_None);
3120
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADD_YIELD_FROM(c, 1);
3121
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP(c, POP_BLOCK); /* for SETUP_FINALLY */
3122
3123 /* Success block for __anext__ */
3124
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 VISIT(c, expr, s->v.AsyncFor.target);
3125
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
✓ Branch 6 taken 3 times.
 9 VISIT_SEQ(c, stmt, s->v.AsyncFor.body);
3126 /* Mark jump as artificial */
3127 3 UNSET_LOC(c);
3128
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP_JUMP(c, JUMP, start);
3129
3130 3 compiler_pop_fblock(c, FOR_LOOP, start);
3131
3132 /* Except block for __anext__ */
3133 3 compiler_use_next_block(c, except);
3134
3135 /* Use same line number as the iterator,
3136 * as the END_ASYNC_FOR succeeds the `for`, not the body. */
3137 3 SET_LOC(c, s->v.AsyncFor.iter);
3138
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP(c, END_ASYNC_FOR);
3139
3140 /* `else` block */
3141
2/6
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
 3 VISIT_SEQ(c, stmt, s->v.For.orelse);
3142
3143 3 compiler_use_next_block(c, end);
3144
3145 3 return 1;
3146 }
3147
3148 static int
3149 4100 compiler_while(struct compiler *c, stmt_ty s)
3150 {
3151 4100 basicblock *loop, *body, *end, *anchor = NULL;
3152 4100 loop = compiler_new_block(c);
3153 4100 body = compiler_new_block(c);
3154 4100 anchor = compiler_new_block(c);
3155 4100 end = compiler_new_block(c);
3156
4/8
✓ Branch 0 taken 4100 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4100 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4100 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4100 times.
 4100 if (loop == NULL || body == NULL || anchor == NULL || end == NULL) {
3157 ✗ return 0;
3158 }
3159 4100 compiler_use_next_block(c, loop);
3160
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4100 times.
 4100 if (!compiler_push_fblock(c, WHILE_LOOP, loop, end, NULL)) {
3161 ✗ return 0;
3162 }
3163
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4100 times.
 4100 if (!compiler_jump_if(c, s->v.While.test, anchor, 0)) {
3164 ✗ return 0;
3165 }
3166
3167 4100 compiler_use_next_block(c, body);
3168
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 14035 times.
✓ Branch 3 taken 18135 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 14035 times.
✓ Branch 6 taken 4100 times.
 18135 VISIT_SEQ(c, stmt, s->v.While.body);
3169 4100 SET_LOC(c, s);
3170
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4100 times.
 4100 if (!compiler_jump_if(c, s->v.While.test, body, 1)) {
3171 ✗ return 0;
3172 }
3173
3174 4100 compiler_pop_fblock(c, WHILE_LOOP, loop);
3175
3176 4100 compiler_use_next_block(c, anchor);
3177
2/2
✓ Branch 0 taken 53 times.
✓ Branch 1 taken 4047 times.
 4100 if (s->v.While.orelse) {
3178
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 71 times.
✓ Branch 3 taken 124 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 71 times.
✓ Branch 6 taken 53 times.
 124 VISIT_SEQ(c, stmt, s->v.While.orelse);
3179 }
3180 4100 compiler_use_next_block(c, end);
3181
3182 4100 return 1;
3183 }
3184
3185 static int
3186 150682 compiler_return(struct compiler *c, stmt_ty s)
3187 {
3188
2/2
✓ Branch 0 taken 147620 times.
✓ Branch 1 taken 3062 times.
 298302 int preserve_tos = ((s->v.Return.value != NULL) &&
3189
2/2
✓ Branch 0 taken 133916 times.
✓ Branch 1 taken 13704 times.
 147620 (s->v.Return.value->kind != Constant_kind));
3190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150682 times.
 150682 if (c->u->u_ste->ste_type != FunctionBlock)
3191 ✗ return compiler_error(c, "'return' outside function");
3192
2/2
✓ Branch 0 taken 147620 times.
✓ Branch 1 taken 3062 times.
 150682 if (s->v.Return.value != NULL &&
3193
3/4
✓ Branch 0 taken 644 times.
✓ Branch 1 taken 146976 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 644 times.
 147620 c->u->u_ste->ste_coroutine && c->u->u_ste->ste_generator)
3194 {
3195 ✗ return compiler_error(
3196 c, "'return' with value in async generator");
3197 }
3198
2/2
✓ Branch 0 taken 133916 times.
✓ Branch 1 taken 16766 times.
 150682 if (preserve_tos) {
3199
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 133916 times.
 133916 VISIT(c, expr, s->v.Return.value);
3200 } else {
3201 /* Emit instruction with line number for return value */
3202
2/2
✓ Branch 0 taken 13704 times.
✓ Branch 1 taken 3062 times.
 16766 if (s->v.Return.value != NULL) {
3203 13704 SET_LOC(c, s->v.Return.value);
3204
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13704 times.
 13704 ADDOP(c, NOP);
3205 }
3206 }
3207
4/4
✓ Branch 0 taken 147620 times.
✓ Branch 1 taken 3062 times.
✓ Branch 2 taken 331 times.
✓ Branch 3 taken 147289 times.
 150682 if (s->v.Return.value == NULL || s->v.Return.value->lineno != s->lineno) {
3208 3393 SET_LOC(c, s);
3209
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3393 times.
 3393 ADDOP(c, NOP);
3210 }
3211
3212
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 150682 times.
 150682 if (!compiler_unwind_fblock_stack(c, preserve_tos, NULL))
3213 ✗ return 0;
3214
2/2
✓ Branch 0 taken 3062 times.
✓ Branch 1 taken 147620 times.
 150682 if (s->v.Return.value == NULL) {
3215
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3062 times.
 3062 ADDOP_LOAD_CONST(c, Py_None);
3216 }
3217
2/2
✓ Branch 0 taken 13704 times.
✓ Branch 1 taken 133916 times.
 147620 else if (!preserve_tos) {
3218
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13704 times.
 13704 ADDOP_LOAD_CONST(c, s->v.Return.value->v.Constant.value);
3219 }
3220
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 150682 times.
 150682 ADDOP(c, RETURN_VALUE);
3221
3222 150682 return 1;
3223 }
3224
3225 static int
3226 2764 compiler_break(struct compiler *c)
3227 {
3228 2764 struct fblockinfo *loop = NULL;
3229 /* Emit instruction with line number */
3230
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2764 times.
 2764 ADDOP(c, NOP);
3231
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2764 times.
 2764 if (!compiler_unwind_fblock_stack(c, 0, &loop)) {
3232 ✗ return 0;
3233 }
3234
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2764 times.
 2764 if (loop == NULL) {
3235 ✗ return compiler_error(c, "'break' outside loop");
3236 }
3237
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2764 times.
 2764 if (!compiler_unwind_fblock(c, loop, 0)) {
3238 ✗ return 0;
3239 }
3240
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2764 times.
 2764 ADDOP_JUMP(c, JUMP, loop->fb_exit);
3241 2764 return 1;
3242 }
3243
3244 static int
3245 2799 compiler_continue(struct compiler *c)
3246 {
3247 2799 struct fblockinfo *loop = NULL;
3248 /* Emit instruction with line number */
3249
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2799 times.
 2799 ADDOP(c, NOP);
3250
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2799 times.
 2799 if (!compiler_unwind_fblock_stack(c, 0, &loop)) {
3251 ✗ return 0;
3252 }
3253
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2799 times.
 2799 if (loop == NULL) {
3254 ✗ return compiler_error(c, "'continue' not properly in loop");
3255 }
3256
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2799 times.
 2799 ADDOP_JUMP(c, JUMP, loop->fb_block);
3257 2799 return 1;
3258 }
3259
3260
3261 /* Code generated for "try: <body> finally: <finalbody>" is as follows:
3262
3263 SETUP_FINALLY L
3264 <code for body>
3265 POP_BLOCK
3266 <code for finalbody>
3267 JUMP E
3268 L:
3269 <code for finalbody>
3270 E:
3271
3272 The special instructions use the block stack. Each block
3273 stack entry contains the instruction that created it (here
3274 SETUP_FINALLY), the level of the value stack at the time the
3275 block stack entry was created, and a label (here L).
3276
3277 SETUP_FINALLY:
3278 Pushes the current value stack level and the label
3279 onto the block stack.
3280 POP_BLOCK:
3281 Pops en entry from the block stack.
3282
3283 The block stack is unwound when an exception is raised:
3284 when a SETUP_FINALLY entry is found, the raised and the caught
3285 exceptions are pushed onto the value stack (and the exception
3286 condition is cleared), and the interpreter jumps to the label
3287 gotten from the block stack.
3288 */
3289
3290 static int
3291 2032 compiler_try_finally(struct compiler *c, stmt_ty s)
3292 {
3293 basicblock *body, *end, *exit, *cleanup;
3294
3295 2032 body = compiler_new_block(c);
3296 2032 end = compiler_new_block(c);
3297 2032 exit = compiler_new_block(c);
3298 2032 cleanup = compiler_new_block(c);
3299
4/8
✓ Branch 0 taken 2032 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2032 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2032 times.
 2032 if (body == NULL || end == NULL || exit == NULL || cleanup == NULL) {
3300 ✗ return 0;
3301 }
3302 /* `try` block */
3303
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 ADDOP_JUMP(c, SETUP_FINALLY, end);
3304 2032 compiler_use_next_block(c, body);
3305
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 if (!compiler_push_fblock(c, FINALLY_TRY, body, end, s->v.Try.finalbody))
3306 ✗ return 0;
3307
4/6
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 1888 times.
✓ Branch 2 taken 144 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 144 times.
✗ Branch 5 not taken.
 2032 if (s->v.Try.handlers && asdl_seq_LEN(s->v.Try.handlers)) {
3308
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 144 times.
 144 if (!compiler_try_except(c, s))
3309 ✗ return 0;
3310 }
3311 else {
3312
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 5484 times.
✓ Branch 3 taken 7372 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5484 times.
✓ Branch 6 taken 1888 times.
 7372 VISIT_SEQ(c, stmt, s->v.Try.body);
3313 }
3314
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 ADDOP_NOLINE(c, POP_BLOCK);
3315 2032 compiler_pop_fblock(c, FINALLY_TRY, body);
3316
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 2439 times.
✓ Branch 3 taken 4471 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2439 times.
✓ Branch 6 taken 2032 times.
 4471 VISIT_SEQ(c, stmt, s->v.Try.finalbody);
3317
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 ADDOP_JUMP_NOLINE(c, JUMP, exit);
3318 /* `finally` block */
3319 2032 compiler_use_next_block(c, end);
3320
3321 2032 UNSET_LOC(c);
3322
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 ADDOP_JUMP(c, SETUP_CLEANUP, cleanup);
3323
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 ADDOP(c, PUSH_EXC_INFO);
3324
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 if (!compiler_push_fblock(c, FINALLY_END, end, NULL, NULL))
3325 ✗ return 0;
3326
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 2439 times.
✓ Branch 3 taken 4471 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2439 times.
✓ Branch 6 taken 2032 times.
 4471 VISIT_SEQ(c, stmt, s->v.Try.finalbody);
3327 2032 compiler_pop_fblock(c, FINALLY_END, end);
3328
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 ADDOP_I(c, RERAISE, 0);
3329 2032 compiler_use_next_block(c, cleanup);
3330
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2032 times.
 2032 POP_EXCEPT_AND_RERAISE(c);
3331 2032 compiler_use_next_block(c, exit);
3332 2032 return 1;
3333 }
3334
3335 static int
3336 ✗ compiler_try_star_finally(struct compiler *c, stmt_ty s)
3337 {
3338 ✗ basicblock *body = compiler_new_block(c);
3339 ✗ if (body == NULL) {
3340 ✗ return 0;
3341 }
3342 ✗ basicblock *end = compiler_new_block(c);
3343 ✗ if (!end) {
3344 ✗ return 0;
3345 }
3346 ✗ basicblock *exit = compiler_new_block(c);
3347 ✗ if (!exit) {
3348 ✗ return 0;
3349 }
3350 ✗ basicblock *cleanup = compiler_new_block(c);
3351 ✗ if (!cleanup) {
3352 ✗ return 0;
3353 }
3354 /* `try` block */
3355 ✗ ADDOP_JUMP(c, SETUP_FINALLY, end);
3356 ✗ compiler_use_next_block(c, body);
3357 ✗ if (!compiler_push_fblock(c, FINALLY_TRY, body, end, s->v.TryStar.finalbody)) {
3358 ✗ return 0;
3359 }
3360 ✗ if (s->v.TryStar.handlers && asdl_seq_LEN(s->v.TryStar.handlers)) {
3361 ✗ if (!compiler_try_star_except(c, s)) {
3362 ✗ return 0;
3363 }
3364 }
3365 else {
3366 ✗ VISIT_SEQ(c, stmt, s->v.TryStar.body);
3367 }
3368 ✗ ADDOP_NOLINE(c, POP_BLOCK);
3369 ✗ compiler_pop_fblock(c, FINALLY_TRY, body);
3370 ✗ VISIT_SEQ(c, stmt, s->v.TryStar.finalbody);
3371 ✗ ADDOP_JUMP_NOLINE(c, JUMP, exit);
3372 /* `finally` block */
3373 ✗ compiler_use_next_block(c, end);
3374
3375 ✗ UNSET_LOC(c);
3376 ✗ ADDOP_JUMP(c, SETUP_CLEANUP, cleanup);
3377 ✗ ADDOP(c, PUSH_EXC_INFO);
3378 ✗ if (!compiler_push_fblock(c, FINALLY_END, end, NULL, NULL)) {
3379 ✗ return 0;
3380 }
3381 ✗ VISIT_SEQ(c, stmt, s->v.TryStar.finalbody);
3382 ✗ compiler_pop_fblock(c, FINALLY_END, end);
3383 ✗ ADDOP_I(c, RERAISE, 0);
3384 ✗ compiler_use_next_block(c, cleanup);
3385 ✗ POP_EXCEPT_AND_RERAISE(c);
3386 ✗ compiler_use_next_block(c, exit);
3387 ✗ return 1;
3388 }
3389
3390
3391 /*
3392 Code generated for "try: S except E1 as V1: S1 except E2 as V2: S2 ...":
3393 (The contents of the value stack is shown in [], with the top
3394 at the right; 'tb' is trace-back info, 'val' the exception's
3395 associated value, and 'exc' the exception.)
3396
3397 Value stack Label Instruction Argument
3398 [] SETUP_FINALLY L1
3399 [] <code for S>
3400 [] POP_BLOCK
3401 [] JUMP L0
3402
3403 [exc] L1: <evaluate E1> )
3404 [exc, E1] CHECK_EXC_MATCH )
3405 [exc, bool] POP_JUMP_IF_FALSE L2 ) only if E1
3406 [exc] <assign to V1> (or POP if no V1)
3407 [] <code for S1>
3408 JUMP L0
3409
3410 [exc] L2: <evaluate E2>
3411 .............................etc.......................
3412
3413 [exc] Ln+1: RERAISE # re-raise exception
3414
3415 [] L0: <next statement>
3416
3417 Of course, parts are not generated if Vi or Ei is not present.
3418 */
3419 static int
3420 11333 compiler_try_except(struct compiler *c, stmt_ty s)
3421 {
3422 basicblock *body, *except, *end, *cleanup;
3423 Py_ssize_t i, n;
3424
3425 11333 body = compiler_new_block(c);
3426 11333 except = compiler_new_block(c);
3427 11333 end = compiler_new_block(c);
3428 11333 cleanup = compiler_new_block(c);
3429
4/8
✓ Branch 0 taken 11333 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11333 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 11333 times.
 11333 if (body == NULL || except == NULL || end == NULL || cleanup == NULL)
3430 ✗ return 0;
3431
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 ADDOP_JUMP(c, SETUP_FINALLY, except);
3432 11333 compiler_use_next_block(c, body);
3433
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 if (!compiler_push_fblock(c, TRY_EXCEPT, body, NULL, NULL))
3434 ✗ return 0;
3435
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 16577 times.
✓ Branch 3 taken 27910 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 16577 times.
✓ Branch 6 taken 11333 times.
 27910 VISIT_SEQ(c, stmt, s->v.Try.body);
3436 11333 compiler_pop_fblock(c, TRY_EXCEPT, body);
3437
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 ADDOP_NOLINE(c, POP_BLOCK);
3438
4/6
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 10099 times.
✓ Branch 2 taken 1234 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1234 times.
✗ Branch 5 not taken.
 11333 if (s->v.Try.orelse && asdl_seq_LEN(s->v.Try.orelse)) {
3439
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 1984 times.
✓ Branch 3 taken 3218 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1984 times.
✓ Branch 6 taken 1234 times.
 3218 VISIT_SEQ(c, stmt, s->v.Try.orelse);
3440 }
3441
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 ADDOP_JUMP_NOLINE(c, JUMP, end);
3442
1/2
✓ Branch 0 taken 11333 times.
✗ Branch 1 not taken.
 11333 n = asdl_seq_LEN(s->v.Try.handlers);
3443 11333 compiler_use_next_block(c, except);
3444
3445 11333 UNSET_LOC(c);
3446
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 ADDOP_JUMP(c, SETUP_CLEANUP, cleanup);
3447
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 ADDOP(c, PUSH_EXC_INFO);
3448 /* Runtime will push a block here, so we need to account for that */
3449
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 if (!compiler_push_fblock(c, EXCEPTION_HANDLER, NULL, NULL, NULL))
3450 ✗ return 0;
3451
2/2
✓ Branch 0 taken 11938 times.
✓ Branch 1 taken 11333 times.
 23271 for (i = 0; i < n; i++) {
3452 11938 excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
3453 s->v.Try.handlers, i);
3454 11938 SET_LOC(c, handler);
3455
3/4
✓ Branch 0 taken 252 times.
✓ Branch 1 taken 11686 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 252 times.
 11938 if (!handler->v.ExceptHandler.type && i < n-1) {
3456 ✗ return compiler_error(c, "default 'except:' must be last");
3457 }
3458 11938 except = compiler_new_block(c);
3459
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11938 times.
 11938 if (except == NULL)
3460 ✗ return 0;
3461
2/2
✓ Branch 0 taken 11686 times.
✓ Branch 1 taken 252 times.
 11938 if (handler->v.ExceptHandler.type) {
3462
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11686 times.
 11686 VISIT(c, expr, handler->v.ExceptHandler.type);
3463
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11686 times.
 11686 ADDOP(c, CHECK_EXC_MATCH);
3464
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11686 times.
 11686 ADDOP_JUMP(c, POP_JUMP_IF_FALSE, except);
3465 }
3466
2/2
✓ Branch 0 taken 2030 times.
✓ Branch 1 taken 9908 times.
 11938 if (handler->v.ExceptHandler.name) {
3467 basicblock *cleanup_end, *cleanup_body;
3468
3469 2030 cleanup_end = compiler_new_block(c);
3470 2030 cleanup_body = compiler_new_block(c);
3471
2/4
✓ Branch 0 taken 2030 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2030 times.
 2030 if (cleanup_end == NULL || cleanup_body == NULL) {
3472 ✗ return 0;
3473 }
3474
3475 2030 compiler_nameop(c, handler->v.ExceptHandler.name, Store);
3476
3477 /*
3478 try:
3479 # body
3480 except type as name:
3481 try:
3482 # body
3483 finally:
3484 name = None # in case body contains "del name"
3485 del name
3486 */
3487
3488 /* second try: */
3489
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP_JUMP(c, SETUP_CLEANUP, cleanup_end);
3490 2030 compiler_use_next_block(c, cleanup_body);
3491
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 if (!compiler_push_fblock(c, HANDLER_CLEANUP, cleanup_body, NULL, handler->v.ExceptHandler.name))
3492 ✗ return 0;
3493
3494 /* second # body */
3495
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 3291 times.
✓ Branch 3 taken 5321 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 3291 times.
✓ Branch 6 taken 2030 times.
 5321 VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
3496 2030 compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body);
3497 /* name = None; del name; # Mark as artificial */
3498 2030 UNSET_LOC(c);
3499
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP(c, POP_BLOCK);
3500
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP(c, POP_BLOCK);
3501
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP(c, POP_EXCEPT);
3502
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP_LOAD_CONST(c, Py_None);
3503 2030 compiler_nameop(c, handler->v.ExceptHandler.name, Store);
3504 2030 compiler_nameop(c, handler->v.ExceptHandler.name, Del);
3505
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP_JUMP(c, JUMP, end);
3506
3507 /* except: */
3508 2030 compiler_use_next_block(c, cleanup_end);
3509
3510 /* name = None; del name; # Mark as artificial */
3511 2030 UNSET_LOC(c);
3512
3513
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP_LOAD_CONST(c, Py_None);
3514 2030 compiler_nameop(c, handler->v.ExceptHandler.name, Store);
3515 2030 compiler_nameop(c, handler->v.ExceptHandler.name, Del);
3516
3517
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2030 times.
 2030 ADDOP_I(c, RERAISE, 1);
3518 }
3519 else {
3520 basicblock *cleanup_body;
3521
3522 9908 cleanup_body = compiler_new_block(c);
3523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9908 times.
 9908 if (!cleanup_body)
3524 ✗ return 0;
3525
3526
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9908 times.
 9908 ADDOP(c, POP_TOP); /* exc_value */
3527 9908 compiler_use_next_block(c, cleanup_body);
3528
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9908 times.
 9908 if (!compiler_push_fblock(c, HANDLER_CLEANUP, cleanup_body, NULL, NULL))
3529 ✗ return 0;
3530
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 12975 times.
✓ Branch 3 taken 22883 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 12975 times.
✓ Branch 6 taken 9908 times.
 22883 VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
3531 9908 compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body);
3532 9908 UNSET_LOC(c);
3533
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9908 times.
 9908 ADDOP(c, POP_BLOCK);
3534
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9908 times.
 9908 ADDOP(c, POP_EXCEPT);
3535
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9908 times.
 9908 ADDOP_JUMP(c, JUMP, end);
3536 }
3537 11938 compiler_use_next_block(c, except);
3538 }
3539 /* Mark as artificial */
3540 11333 UNSET_LOC(c);
3541 11333 compiler_pop_fblock(c, EXCEPTION_HANDLER, NULL);
3542
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 ADDOP_I(c, RERAISE, 0);
3543 11333 compiler_use_next_block(c, cleanup);
3544
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11333 times.
 11333 POP_EXCEPT_AND_RERAISE(c);
3545 11333 compiler_use_next_block(c, end);
3546 11333 return 1;
3547 }
3548
3549 /*
3550 Code generated for "try: S except* E1 as V1: S1 except* E2 as V2: S2 ...":
3551 (The contents of the value stack is shown in [], with the top
3552 at the right; 'tb' is trace-back info, 'val' the exception instance,
3553 and 'typ' the exception's type.)
3554
3555 Value stack Label Instruction Argument
3556 [] SETUP_FINALLY L1
3557 [] <code for S>
3558 [] POP_BLOCK
3559 [] JUMP L0
3560
3561 [exc] L1: COPY 1 ) save copy of the original exception
3562 [orig, exc] BUILD_LIST ) list for raised/reraised excs ("result")
3563 [orig, exc, res] SWAP 2
3564
3565 [orig, res, exc] <evaluate E1>
3566 [orig, res, exc, E1] CHECK_EG_MATCH
3567 [orig, red, rest/exc, match?] COPY 1
3568 [orig, red, rest/exc, match?, match?] POP_JUMP_IF_NOT_NONE H1
3569 [orig, red, exc, None] POP_TOP
3570 [orig, red, exc] JUMP L2
3571
3572 [orig, res, rest, match] H1: <assign to V1> (or POP if no V1)
3573
3574 [orig, res, rest] SETUP_FINALLY R1
3575 [orig, res, rest] <code for S1>
3576 [orig, res, rest] JUMP L2
3577
3578 [orig, res, rest, i, v] R1: LIST_APPEND 3 ) exc raised in except* body - add to res
3579 [orig, res, rest, i] POP
3580
3581 [orig, res, rest] L2: <evaluate E2>
3582 .............................etc.......................
3583
3584 [orig, res, rest] Ln+1: LIST_APPEND 1 ) add unhandled exc to res (could be None)
3585
3586 [orig, res] PREP_RERAISE_STAR
3587 [exc] COPY 1
3588 [exc, exc] POP_JUMP_IF_NOT_NONE RER
3589 [exc] POP_TOP
3590 [] JUMP L0
3591
3592 [exc] RER: SWAP 2
3593 [exc, prev_exc_info] POP_EXCEPT
3594 [exc] RERAISE 0
3595
3596 [] L0: <next statement>
3597 */
3598 static int
3599 ✗ compiler_try_star_except(struct compiler *c, stmt_ty s)
3600 {
3601 ✗ basicblock *body = compiler_new_block(c);
3602 ✗ if (body == NULL) {
3603 ✗ return 0;
3604 }
3605 ✗ basicblock *except = compiler_new_block(c);
3606 ✗ if (except == NULL) {
3607 ✗ return 0;
3608 }
3609 ✗ basicblock *orelse = compiler_new_block(c);
3610 ✗ if (orelse == NULL) {
3611 ✗ return 0;
3612 }
3613 ✗ basicblock *end = compiler_new_block(c);
3614 ✗ if (end == NULL) {
3615 ✗ return 0;
3616 }
3617 ✗ basicblock *cleanup = compiler_new_block(c);
3618 ✗ if (cleanup == NULL) {
3619 ✗ return 0;
3620 }
3621 ✗ basicblock *reraise_star = compiler_new_block(c);
3622 ✗ if (reraise_star == NULL) {
3623 ✗ return 0;
3624 }
3625
3626 ✗ ADDOP_JUMP(c, SETUP_FINALLY, except);
3627 ✗ compiler_use_next_block(c, body);
3628 ✗ if (!compiler_push_fblock(c, TRY_EXCEPT, body, NULL, NULL)) {
3629 ✗ return 0;
3630 }
3631 ✗ VISIT_SEQ(c, stmt, s->v.TryStar.body);
3632 ✗ compiler_pop_fblock(c, TRY_EXCEPT, body);
3633 ✗ ADDOP_NOLINE(c, POP_BLOCK);
3634 ✗ ADDOP_JUMP_NOLINE(c, JUMP, orelse);
3635 ✗ Py_ssize_t n = asdl_seq_LEN(s->v.TryStar.handlers);
3636 ✗ compiler_use_next_block(c, except);
3637
3638 ✗ UNSET_LOC(c);
3639 ✗ ADDOP_JUMP(c, SETUP_CLEANUP, cleanup);
3640 ✗ ADDOP(c, PUSH_EXC_INFO);
3641 /* Runtime will push a block here, so we need to account for that */
3642 ✗ if (!compiler_push_fblock(c, EXCEPTION_GROUP_HANDLER,
3643 NULL, NULL, "except handler")) {
3644 ✗ return 0;
3645 }
3646 ✗ for (Py_ssize_t i = 0; i < n; i++) {
3647 ✗ excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
3648 s->v.TryStar.handlers, i);
3649 ✗ SET_LOC(c, handler);
3650 ✗ except = compiler_new_block(c);
3651 ✗ if (except == NULL) {
3652 ✗ return 0;
3653 }
3654 ✗ basicblock *handle_match = compiler_new_block(c);
3655 ✗ if (handle_match == NULL) {
3656 ✗ return 0;
3657 }
3658 ✗ if (i == 0) {
3659 /* Push the original EG into the stack */
3660 /*
3661 [exc] COPY 1
3662 [orig, exc]
3663 */
3664 ✗ ADDOP_I(c, COPY, 1);
3665
3666 /* create empty list for exceptions raised/reraise in the except* blocks */
3667 /*
3668 [orig, exc] BUILD_LIST
3669 [orig, exc, []] SWAP 2
3670 [orig, [], exc]
3671 */
3672 ✗ ADDOP_I(c, BUILD_LIST, 0);
3673 ✗ ADDOP_I(c, SWAP, 2);
3674 }
3675 ✗ if (handler->v.ExceptHandler.type) {
3676 ✗ VISIT(c, expr, handler->v.ExceptHandler.type);
3677 ✗ ADDOP(c, CHECK_EG_MATCH);
3678 ✗ ADDOP_I(c, COPY, 1);
3679 ✗ ADDOP_JUMP(c, POP_JUMP_IF_NOT_NONE, handle_match);
3680 ✗ ADDOP(c, POP_TOP); // match
3681 ✗ ADDOP_JUMP(c, JUMP, except);
3682 }
3683
3684 ✗ compiler_use_next_block(c, handle_match);
3685
3686 ✗ basicblock *cleanup_end = compiler_new_block(c);
3687 ✗ if (cleanup_end == NULL) {
3688 ✗ return 0;
3689 }
3690 ✗ basicblock *cleanup_body = compiler_new_block(c);
3691 ✗ if (cleanup_body == NULL) {
3692 ✗ return 0;
3693 }
3694
3695 ✗ if (handler->v.ExceptHandler.name) {
3696 ✗ compiler_nameop(c, handler->v.ExceptHandler.name, Store);
3697 }
3698 else {
3699 ✗ ADDOP(c, POP_TOP); // match
3700 }
3701
3702 /*
3703 try:
3704 # body
3705 except type as name:
3706 try:
3707 # body
3708 finally:
3709 name = None # in case body contains "del name"
3710 del name
3711 */
3712 /* second try: */
3713 ✗ ADDOP_JUMP(c, SETUP_CLEANUP, cleanup_end);
3714 ✗ compiler_use_next_block(c, cleanup_body);
3715 ✗ if (!compiler_push_fblock(c, HANDLER_CLEANUP, cleanup_body, NULL, handler->v.ExceptHandler.name))
3716 ✗ return 0;
3717
3718 /* second # body */
3719 ✗ VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
3720 ✗ compiler_pop_fblock(c, HANDLER_CLEANUP, cleanup_body);
3721 /* name = None; del name; # Mark as artificial */
3722 ✗ UNSET_LOC(c);
3723 ✗ ADDOP(c, POP_BLOCK);
3724 ✗ if (handler->v.ExceptHandler.name) {
3725 ✗ ADDOP_LOAD_CONST(c, Py_None);
3726 ✗ compiler_nameop(c, handler->v.ExceptHandler.name, Store);
3727 ✗ compiler_nameop(c, handler->v.ExceptHandler.name, Del);
3728 }
3729 ✗ ADDOP_JUMP(c, JUMP, except);
3730
3731 /* except: */
3732 ✗ compiler_use_next_block(c, cleanup_end);
3733
3734 /* name = None; del name; # Mark as artificial */
3735 ✗ UNSET_LOC(c);
3736
3737 ✗ if (handler->v.ExceptHandler.name) {
3738 ✗ ADDOP_LOAD_CONST(c, Py_None);
3739 ✗ compiler_nameop(c, handler->v.ExceptHandler.name, Store);
3740 ✗ compiler_nameop(c, handler->v.ExceptHandler.name, Del);
3741 }
3742
3743 /* add exception raised to the res list */
3744 ✗ ADDOP_I(c, LIST_APPEND, 3); // exc
3745 ✗ ADDOP(c, POP_TOP); // lasti
3746
3747 ✗ ADDOP_JUMP(c, JUMP, except);
3748 ✗ compiler_use_next_block(c, except);
3749
3750 ✗ if (i == n - 1) {
3751 /* Add exc to the list (if not None it's the unhandled part of the EG) */
3752 ✗ ADDOP_I(c, LIST_APPEND, 1);
3753 ✗ ADDOP_JUMP(c, JUMP, reraise_star);
3754 }
3755 }
3756 /* Mark as artificial */
3757 ✗ UNSET_LOC(c);
3758 ✗ compiler_pop_fblock(c, EXCEPTION_GROUP_HANDLER, NULL);
3759 ✗ basicblock *reraise = compiler_new_block(c);
3760 ✗ if (!reraise) {
3761 ✗ return 0;
3762 }
3763
3764 ✗ compiler_use_next_block(c, reraise_star);
3765 ✗ ADDOP(c, PREP_RERAISE_STAR);
3766 ✗ ADDOP_I(c, COPY, 1);
3767 ✗ ADDOP_JUMP(c, POP_JUMP_IF_NOT_NONE, reraise);
3768
3769 /* Nothing to reraise */
3770 ✗ ADDOP(c, POP_TOP);
3771 ✗ ADDOP(c, POP_BLOCK);
3772 ✗ ADDOP(c, POP_EXCEPT);
3773 ✗ ADDOP_JUMP(c, JUMP, end);
3774 ✗ compiler_use_next_block(c, reraise);
3775 ✗ ADDOP(c, POP_BLOCK);
3776 ✗ ADDOP_I(c, SWAP, 2);
3777 ✗ ADDOP(c, POP_EXCEPT);
3778 ✗ ADDOP_I(c, RERAISE, 0);
3779 ✗ compiler_use_next_block(c, cleanup);
3780 ✗ POP_EXCEPT_AND_RERAISE(c);
3781 ✗ compiler_use_next_block(c, orelse);
3782 ✗ VISIT_SEQ(c, stmt, s->v.TryStar.orelse);
3783 ✗ compiler_use_next_block(c, end);
3784 ✗ return 1;
3785 }
3786
3787 static int
3788 13221 compiler_try(struct compiler *c, stmt_ty s) {
3789
4/6
✓ Branch 0 taken 2032 times.
✓ Branch 1 taken 11189 times.
✓ Branch 2 taken 2032 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2032 times.
✗ Branch 5 not taken.
 13221 if (s->v.Try.finalbody && asdl_seq_LEN(s->v.Try.finalbody))
3790 2032 return compiler_try_finally(c, s);
3791 else
3792 11189 return compiler_try_except(c, s);
3793 }
3794
3795 static int
3796 ✗ compiler_try_star(struct compiler *c, stmt_ty s)
3797 {
3798 ✗ if (s->v.TryStar.finalbody && asdl_seq_LEN(s->v.TryStar.finalbody)) {
3799 ✗ return compiler_try_star_finally(c, s);
3800 }
3801 else {
3802 ✗ return compiler_try_star_except(c, s);
3803 }
3804 }
3805
3806 static int
3807 491 compiler_import_as(struct compiler *c, identifier name, identifier asname)
3808 {
3809 /* The IMPORT_NAME opcode was already generated. This function
3810 merely needs to bind the result to a name.
3811
3812 If there is a dot in name, we need to split it and emit a
3813 IMPORT_FROM for each name.
3814 */
3815 491 Py_ssize_t len = PyUnicode_GET_LENGTH(name);
3816 491 Py_ssize_t dot = PyUnicode_FindChar(name, '.', 0, len, 1);
3817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 491 times.
 491 if (dot == -2)
3818 ✗ return 0;
3819
2/2
✓ Branch 0 taken 250 times.
✓ Branch 1 taken 241 times.
 491 if (dot != -1) {
3820 /* Consume the base module name to get the first attribute */
3821 166 while (1) {
3822 416 Py_ssize_t pos = dot + 1;
3823 PyObject *attr;
3824 416 dot = PyUnicode_FindChar(name, '.', pos, len, 1);
3825
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 416 times.
 416 if (dot == -2)
3826 ✗ return 0;
3827
2/2
✓ Branch 0 taken 166 times.
✓ Branch 1 taken 250 times.
 416 attr = PyUnicode_Substring(name, pos, (dot != -1) ? dot : len);
3828
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 416 times.
 416 if (!attr)
3829 ✗ return 0;
3830
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 416 times.
 416 ADDOP_N(c, IMPORT_FROM, attr, names);
3831
2/2
✓ Branch 0 taken 250 times.
✓ Branch 1 taken 166 times.
 416 if (dot == -1) {
3832 250 break;
3833 }
3834
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 166 times.
 166 ADDOP_I(c, SWAP, 2);
3835
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 166 times.
 166 ADDOP(c, POP_TOP);
3836 }
3837
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 250 times.
 250 if (!compiler_nameop(c, asname, Store)) {
3838 ✗ return 0;
3839 }
3840
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 250 times.
 250 ADDOP(c, POP_TOP);
3841 250 return 1;
3842 }
3843 241 return compiler_nameop(c, asname, Store);
3844 }
3845
3846 static int
3847 22091 compiler_import(struct compiler *c, stmt_ty s)
3848 {
3849 /* The Import node stores a module name like a.b.c as a single
3850 string. This is convenient for all cases except
3851 import a.b.c as d
3852 where we need to parse that string to extract the individual
3853 module names.
3854 XXX Perhaps change the representation to make this case simpler?
3855 */
3856
1/2
✓ Branch 0 taken 22091 times.
✗ Branch 1 not taken.
 22091 Py_ssize_t i, n = asdl_seq_LEN(s->v.Import.names);
3857
3858 22091 PyObject *zero = _PyLong_GetZero(); // borrowed reference
3859
2/2
✓ Branch 0 taken 22237 times.
✓ Branch 1 taken 22091 times.
 44328 for (i = 0; i < n; i++) {
3860 22237 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i);
3861 int r;
3862
3863
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22237 times.
 22237 ADDOP_LOAD_CONST(c, zero);
3864
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22237 times.
 22237 ADDOP_LOAD_CONST(c, Py_None);
3865
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22237 times.
 22237 ADDOP_NAME(c, IMPORT_NAME, alias->name, names);
3866
3867
2/2
✓ Branch 0 taken 491 times.
✓ Branch 1 taken 21746 times.
 22237 if (alias->asname) {
3868 491 r = compiler_import_as(c, alias->name, alias->asname);
3869
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 491 times.
 491 if (!r)
3870 ✗ return r;
3871 }
3872 else {
3873 21746 identifier tmp = alias->name;
3874 21746 Py_ssize_t dot = PyUnicode_FindChar(
3875 21746 alias->name, '.', 0, PyUnicode_GET_LENGTH(alias->name), 1);
3876
2/2
✓ Branch 0 taken 593 times.
✓ Branch 1 taken 21153 times.
 21746 if (dot != -1) {
3877 593 tmp = PyUnicode_Substring(alias->name, 0, dot);
3878
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 593 times.
 593 if (tmp == NULL)
3879 ✗ return 0;
3880 }
3881 21746 r = compiler_nameop(c, tmp, Store);
3882
2/2
✓ Branch 0 taken 593 times.
✓ Branch 1 taken 21153 times.
 21746 if (dot != -1) {
3883 593 Py_DECREF(tmp);
3884 }
3885
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21746 times.
 21746 if (!r)
3886 ✗ return r;
3887 }
3888 }
3889 22091 return 1;
3890 }
3891
3892 static int
3893 33825 compiler_from_import(struct compiler *c, stmt_ty s)
3894 {
3895
1/2
✓ Branch 0 taken 33825 times.
✗ Branch 1 not taken.
 33825 Py_ssize_t i, n = asdl_seq_LEN(s->v.ImportFrom.names);
3896 PyObject *names;
3897
3898
2/4
✗ Branch 1 not taken.
✓ Branch 2 taken 33825 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 33825 times.
 33825 ADDOP_LOAD_CONST_NEW(c, PyLong_FromLong(s->v.ImportFrom.level));
3899
3900 33825 names = PyTuple_New(n);
3901
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 33825 times.
 33825 if (!names)
3902 ✗ return 0;
3903
3904 /* build up the names */
3905
2/2
✓ Branch 0 taken 83370 times.
✓ Branch 1 taken 33825 times.
 117195 for (i = 0; i < n; i++) {
3906 83370 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
3907 83370 Py_INCREF(alias->name);
3908 83370 PyTuple_SET_ITEM(names, i, alias->name);
3909 }
3910
3911
5/6
✓ Branch 0 taken 33462 times.
✓ Branch 1 taken 363 times.
✓ Branch 2 taken 32089 times.
✓ Branch 3 taken 1373 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 32089 times.
 65914 if (s->lineno > c->c_future->ff_lineno && s->v.ImportFrom.module &&
3912 32089 _PyUnicode_EqualToASCIIString(s->v.ImportFrom.module, "__future__")) {
3913 ✗ Py_DECREF(names);
3914 ✗ return compiler_error(c, "from __future__ imports must occur "
3915 "at the beginning of the file");
3916 }
3917
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 33825 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33825 times.
 33825 ADDOP_LOAD_CONST_NEW(c, names);
3918
3919
2/2
✓ Branch 0 taken 32452 times.
✓ Branch 1 taken 1373 times.
 33825 if (s->v.ImportFrom.module) {
3920
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32452 times.
 32452 ADDOP_NAME(c, IMPORT_NAME, s->v.ImportFrom.module, names);
3921 }
3922 else {
3923 _Py_DECLARE_STR(empty, "");
3924
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1373 times.
 1373 ADDOP_NAME(c, IMPORT_NAME, &_Py_STR(empty), names);
3925 }
3926
2/2
✓ Branch 0 taken 83370 times.
✓ Branch 1 taken 32467 times.
 115837 for (i = 0; i < n; i++) {
3927 83370 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
3928 identifier store_name;
3929
3930
4/4
✓ Branch 0 taken 33825 times.
✓ Branch 1 taken 49545 times.
✓ Branch 3 taken 1358 times.
✓ Branch 4 taken 32467 times.
 83370 if (i == 0 && PyUnicode_READ_CHAR(alias->name, 0) == '*') {
3931 assert(n == 1);
3932
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1358 times.
 1358 ADDOP(c, IMPORT_STAR);
3933 1358 return 1;
3934 }
3935
3936
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 82012 times.
 82012 ADDOP_NAME(c, IMPORT_FROM, alias->name, names);
3937 82012 store_name = alias->name;
3938
2/2
✓ Branch 0 taken 1526 times.
✓ Branch 1 taken 80486 times.
 82012 if (alias->asname)
3939 1526 store_name = alias->asname;
3940
3941
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 82012 times.
 82012 if (!compiler_nameop(c, store_name, Store)) {
3942 ✗ return 0;
3943 }
3944 }
3945 /* remove imported module */
3946
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32467 times.
 32467 ADDOP(c, POP_TOP);
3947 32467 return 1;
3948 }
3949
3950 static int
3951 77862 compiler_assert(struct compiler *c, stmt_ty s)
3952 {
3953 basicblock *end;
3954
3955 /* Always emit a warning if the test is a non-zero length tuple */
3956
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77862 times.
 77862 if ((s->v.Assert.test->kind == Tuple_kind &&
3957 ✗ asdl_seq_LEN(s->v.Assert.test->v.Tuple.elts) > 0) ||
3958
3/4
✓ Branch 0 taken 109 times.
✓ Branch 1 taken 77753 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 109 times.
 77971 (s->v.Assert.test->kind == Constant_kind &&
3959
0/2
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 109 PyTuple_Check(s->v.Assert.test->v.Constant.value) &&
3960 ✗ PyTuple_Size(s->v.Assert.test->v.Constant.value) > 0))
3961 {
3962 ✗ if (!compiler_warn(c, "assertion is always true, "
3963 "perhaps remove parentheses?"))
3964 {
3965 ✗ return 0;
3966 }
3967 }
3968
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77862 times.
 77862 if (c->c_optimize)
3969 ✗ return 1;
3970 77862 end = compiler_new_block(c);
3971
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 77862 times.
 77862 if (end == NULL)
3972 ✗ return 0;
3973
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 77862 times.
 77862 if (!compiler_jump_if(c, s->v.Assert.test, end, 1))
3974 ✗ return 0;
3975
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 77862 times.
 77862 ADDOP(c, LOAD_ASSERTION_ERROR);
3976
2/2
✓ Branch 0 taken 833 times.
✓ Branch 1 taken 77029 times.
 77862 if (s->v.Assert.msg) {
3977
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 833 times.
 833 VISIT(c, expr, s->v.Assert.msg);
3978
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 833 times.
 833 ADDOP_I(c, CALL, 0);
3979 }
3980
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 77862 times.
 77862 ADDOP_I(c, RAISE_VARARGS, 1);
3981 77862 compiler_use_next_block(c, end);
3982 77862 return 1;
3983 }
3984
3985 static int
3986 161761 compiler_visit_stmt_expr(struct compiler *c, expr_ty value)
3987 {
3988
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 161761 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 161761 if (c->c_interactive && c->c_nestlevel <= 1) {
3989 ✗ VISIT(c, expr, value);
3990 ✗ ADDOP(c, PRINT_EXPR);
3991 ✗ return 1;
3992 }
3993
3994
2/2
✓ Branch 0 taken 891 times.
✓ Branch 1 taken 160870 times.
 161761 if (value->kind == Constant_kind) {
3995 /* ignore constant statement */
3996
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 891 times.
 891 ADDOP(c, NOP);
3997 891 return 1;
3998 }
3999
4000
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160870 times.
 160870 VISIT(c, expr, value);
4001 /* Mark POP_TOP as artificial */
4002 160870 UNSET_LOC(c);
4003
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 160870 times.
 160870 ADDOP(c, POP_TOP);
4004 160870 return 1;
4005 }
4006
4007 static int
4008 1287939 compiler_visit_stmt(struct compiler *c, stmt_ty s)
4009 {
4010 Py_ssize_t i, n;
4011
4012 /* Always assign a lineno to the next instruction for a stmt. */
4013 1287939 SET_LOC(c, s);
4014
4015
25/27
✓ Branch 0 taken 159636 times.
✓ Branch 1 taken 15204 times.
✓ Branch 2 taken 150682 times.
✓ Branch 3 taken 1652 times.
✓ Branch 4 taken 421319 times.
✓ Branch 5 taken 15223 times.
✓ Branch 6 taken 2553 times.
✓ Branch 7 taken 33890 times.
✓ Branch 8 taken 4100 times.
✓ Branch 9 taken 137065 times.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 20907 times.
✓ Branch 12 taken 13221 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 77862 times.
✓ Branch 15 taken 22091 times.
✓ Branch 16 taken 33825 times.
✓ Branch 17 taken 530 times.
✓ Branch 18 taken 161761 times.
✓ Branch 19 taken 5399 times.
✓ Branch 20 taken 2764 times.
✓ Branch 21 taken 2799 times.
✓ Branch 22 taken 4330 times.
✓ Branch 23 taken 1106 times.
✓ Branch 24 taken 14 times.
✓ Branch 25 taken 3 times.
✗ Branch 26 not taken.
 1287939 switch (s->kind) {
4016 159636 case FunctionDef_kind:
4017 159636 return compiler_function(c, s, 0);
4018 15204 case ClassDef_kind:
4019 15204 return compiler_class(c, s);
4020 150682 case Return_kind:
4021 150682 return compiler_return(c, s);
4022 1652 case Delete_kind:
4023
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 1764 times.
✓ Branch 3 taken 3416 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1764 times.
✓ Branch 6 taken 1652 times.
 3416 VISIT_SEQ(c, expr, s->v.Delete.targets)
4024 1652 break;
4025 421319 case Assign_kind:
4026
1/2
✓ Branch 0 taken 421319 times.
✗ Branch 1 not taken.
 421319 n = asdl_seq_LEN(s->v.Assign.targets);
4027
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 421319 times.
 421319 VISIT(c, expr, s->v.Assign.value);
4028
2/2
✓ Branch 0 taken 423439 times.
✓ Branch 1 taken 421319 times.
 844758 for (i = 0; i < n; i++) {
4029
2/2
✓ Branch 0 taken 2120 times.
✓ Branch 1 taken 421319 times.
 423439 if (i < n - 1) {
4030
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2120 times.
 2120 ADDOP_I(c, COPY, 1);
4031 }
4032
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 423439 times.
 423439 VISIT(c, expr,
4033 (expr_ty)asdl_seq_GET(s->v.Assign.targets, i));
4034 }
4035 421319 break;
4036 15223 case AugAssign_kind:
4037 15223 return compiler_augassign(c, s);
4038 2553 case AnnAssign_kind:
4039 2553 return compiler_annassign(c, s);
4040 33890 case For_kind:
4041 33890 return compiler_for(c, s);
4042 4100 case While_kind:
4043 4100 return compiler_while(c, s);
4044 137065 case If_kind:
4045 137065 return compiler_if(c, s);
4046 3 case Match_kind:
4047 3 return compiler_match(c, s);
4048 20907 case Raise_kind:
4049 20907 n = 0;
4050
2/2
✓ Branch 0 taken 19699 times.
✓ Branch 1 taken 1208 times.
 20907 if (s->v.Raise.exc) {
4051
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19699 times.
 19699 VISIT(c, expr, s->v.Raise.exc);
4052 19699 n++;
4053
2/2
✓ Branch 0 taken 967 times.
✓ Branch 1 taken 18732 times.
 19699 if (s->v.Raise.cause) {
4054
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 967 times.
 967 VISIT(c, expr, s->v.Raise.cause);
4055 967 n++;
4056 }
4057 }
4058
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20907 times.
 20907 ADDOP_I(c, RAISE_VARARGS, (int)n);
4059 20907 break;
4060 13221 case Try_kind:
4061 13221 return compiler_try(c, s);
4062 ✗ case TryStar_kind:
4063 ✗ return compiler_try_star(c, s);
4064 77862 case Assert_kind:
4065 77862 return compiler_assert(c, s);
4066 22091 case Import_kind:
4067 22091 return compiler_import(c, s);
4068 33825 case ImportFrom_kind:
4069 33825 return compiler_from_import(c, s);
4070 530 case Global_kind:
4071 case Nonlocal_kind:
4072 530 break;
4073 161761 case Expr_kind:
4074 161761 return compiler_visit_stmt_expr(c, s->v.Expr.value);
4075 5399 case Pass_kind:
4076
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5399 times.
 5399 ADDOP(c, NOP);
4077 5399 break;
4078 2764 case Break_kind:
4079 2764 return compiler_break(c);
4080 2799 case Continue_kind:
4081 2799 return compiler_continue(c);
4082 4330 case With_kind:
4083 4330 return compiler_with(c, s, 0);
4084 1106 case AsyncFunctionDef_kind:
4085 1106 return compiler_function(c, s, 1);
4086 14 case AsyncWith_kind:
4087 14 return compiler_async_with(c, s, 0);
4088 3 case AsyncFor_kind:
4089 3 return compiler_async_for(c, s);
4090 }
4091
4092 449807 return 1;
4093 }
4094
4095 static int
4096 47921 unaryop(unaryop_ty op)
4097 {
4098
4/5
✓ Branch 0 taken 1028 times.
✓ Branch 1 taken 1635 times.
✓ Branch 2 taken 149 times.
✓ Branch 3 taken 45109 times.
✗ Branch 4 not taken.
 47921 switch (op) {
4099 1028 case Invert:
4100 1028 return UNARY_INVERT;
4101 1635 case Not:
4102 1635 return UNARY_NOT;
4103 149 case UAdd:
4104 149 return UNARY_POSITIVE;
4105 45109 case USub:
4106 45109 return UNARY_NEGATIVE;
4107 ✗ default:
4108 ✗ PyErr_Format(PyExc_SystemError,
4109 "unary op %d should not be possible", op);
4110 ✗ return 0;
4111 }
4112 }
4113
4114 static int
4115 1183551 addop_binary(struct compiler *c, operator_ty binop, bool inplace)
4116 {
4117 int oparg;
4118
13/14
✓ Branch 0 taken 287426 times.
✓ Branch 1 taken 68513 times.
✓ Branch 2 taken 471841 times.
✓ Branch 3 taken 17 times.
✓ Branch 4 taken 126196 times.
✓ Branch 5 taken 13581 times.
✓ Branch 6 taken 204773 times.
✓ Branch 7 taken 1595 times.
✓ Branch 8 taken 1405 times.
✓ Branch 9 taken 2298 times.
✓ Branch 10 taken 396 times.
✓ Branch 11 taken 3544 times.
✓ Branch 12 taken 1966 times.
✗ Branch 13 not taken.
 1183551 switch (binop) {
4119 287426 case Add:
4120
2/2
✓ Branch 0 taken 10626 times.
✓ Branch 1 taken 276800 times.
 287426 oparg = inplace ? NB_INPLACE_ADD : NB_ADD;
4121 287426 break;
4122 68513 case Sub:
4123
2/2
✓ Branch 0 taken 2084 times.
✓ Branch 1 taken 66429 times.
 68513 oparg = inplace ? NB_INPLACE_SUBTRACT : NB_SUBTRACT;
4124 68513 break;
4125 471841 case Mult:
4126
2/2
✓ Branch 0 taken 1084 times.
✓ Branch 1 taken 470757 times.
 471841 oparg = inplace ? NB_INPLACE_MULTIPLY : NB_MULTIPLY;
4127 471841 break;
4128 17 case MatMult:
4129
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16 times.
 17 oparg = inplace ? NB_INPLACE_MATRIX_MULTIPLY : NB_MATRIX_MULTIPLY;
4130 17 break;
4131 126196 case Div:
4132
2/2
✓ Branch 0 taken 212 times.
✓ Branch 1 taken 125984 times.
 126196 oparg = inplace ? NB_INPLACE_TRUE_DIVIDE : NB_TRUE_DIVIDE;
4133 126196 break;
4134 13581 case Mod:
4135
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 13539 times.
 13581 oparg = inplace ? NB_INPLACE_REMAINDER : NB_REMAINDER;
4136 13581 break;
4137 204773 case Pow:
4138
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 204770 times.
 204773 oparg = inplace ? NB_INPLACE_POWER : NB_POWER;
4139 204773 break;
4140 1595 case LShift:
4141
2/2
✓ Branch 0 taken 175 times.
✓ Branch 1 taken 1420 times.
 1595 oparg = inplace ? NB_INPLACE_LSHIFT : NB_LSHIFT;
4142 1595 break;
4143 1405 case RShift:
4144
2/2
✓ Branch 0 taken 286 times.
✓ Branch 1 taken 1119 times.
 1405 oparg = inplace ? NB_INPLACE_RSHIFT : NB_RSHIFT;
4145 1405 break;
4146 2298 case BitOr:
4147
2/2
✓ Branch 0 taken 389 times.
✓ Branch 1 taken 1909 times.
 2298 oparg = inplace ? NB_INPLACE_OR : NB_OR;
4148 2298 break;
4149 396 case BitXor:
4150
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 299 times.
 396 oparg = inplace ? NB_INPLACE_XOR : NB_XOR;
4151 396 break;
4152 3544 case BitAnd:
4153
2/2
✓ Branch 0 taken 123 times.
✓ Branch 1 taken 3421 times.
 3544 oparg = inplace ? NB_INPLACE_AND : NB_AND;
4154 3544 break;
4155 1966 case FloorDiv:
4156
2/2
✓ Branch 0 taken 101 times.
✓ Branch 1 taken 1865 times.
 1966 oparg = inplace ? NB_INPLACE_FLOOR_DIVIDE : NB_FLOOR_DIVIDE;
4157 1966 break;
4158 ✗ default:
4159 ✗ PyErr_Format(PyExc_SystemError, "%s op %d should not be possible",
4160 inplace ? "inplace" : "binary", binop);
4161 ✗ return 0;
4162 }
4163
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1183551 times.
 1183551 ADDOP_I(c, BINARY_OP, oparg);
4164 1183551 return 1;
4165 }
4166
4167
4168 static int
4169 10259 addop_yield(struct compiler *c) {
4170
3/4
✓ Branch 0 taken 10259 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 10251 times.
 10259 if (c->u->u_ste->ste_generator && c->u->u_ste->ste_coroutine) {
4171
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
 8 ADDOP(c, ASYNC_GEN_WRAP);
4172 }
4173
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10259 times.
 10259 ADDOP_I(c, YIELD_VALUE, 0);
4174
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10259 times.
 10259 ADDOP_I(c, RESUME, 1);
4175 10259 return 1;
4176 }
4177
4178 static int
4179 5174336 compiler_nameop(struct compiler *c, identifier name, expr_context_ty ctx)
4180 {
4181 int op, scope;
4182 Py_ssize_t arg;
4183 enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } optype;
4184
4185 5174336 PyObject *dict = c->u->u_names;
4186 PyObject *mangled;
4187
4188 assert(!_PyUnicode_EqualToASCIIString(name, "None") &&
4189 !_PyUnicode_EqualToASCIIString(name, "True") &&
4190 !_PyUnicode_EqualToASCIIString(name, "False"));
4191
4192
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5174336 times.
 5174336 if (forbidden_name(c, name, ctx))
4193 ✗ return 0;
4194
4195 5174336 mangled = _Py_Mangle(c->u->u_private, name);
4196
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5174336 times.
 5174336 if (!mangled)
4197 ✗ return 0;
4198
4199 5174336 op = 0;
4200 5174336 optype = OP_NAME;
4201 5174336 scope = _PyST_GetScope(c->u->u_ste, mangled);
4202
6/6
✓ Branch 0 taken 28436 times.
✓ Branch 1 taken 58657 times.
✓ Branch 2 taken 3186878 times.
✓ Branch 3 taken 1839467 times.
✓ Branch 4 taken 1867 times.
✓ Branch 5 taken 59031 times.
 5174336 switch (scope) {
4203 28436 case FREE:
4204 28436 dict = c->u->u_freevars;
4205 28436 optype = OP_DEREF;
4206 28436 break;
4207 58657 case CELL:
4208 58657 dict = c->u->u_cellvars;
4209 58657 optype = OP_DEREF;
4210 58657 break;
4211 3186878 case LOCAL:
4212
2/2
✓ Branch 0 taken 2744759 times.
✓ Branch 1 taken 442119 times.
 3186878 if (c->u->u_ste->ste_type == FunctionBlock)
4213 2744759 optype = OP_FAST;
4214 3186878 break;
4215 1839467 case GLOBAL_IMPLICIT:
4216
2/2
✓ Branch 0 taken 1748995 times.
✓ Branch 1 taken 90472 times.
 1839467 if (c->u->u_ste->ste_type == FunctionBlock)
4217 1748995 optype = OP_GLOBAL;
4218 1839467 break;
4219 1867 case GLOBAL_EXPLICIT:
4220 1867 optype = OP_GLOBAL;
4221 1867 break;
4222 59031 default:
4223 /* scope can be 0 */
4224 59031 break;
4225 }
4226
4227 /* XXX Leave assert here, but handle __doc__ and the like better */
4228 assert(scope || PyUnicode_READ_CHAR(name, 0) == '_');
4229
4230
4/5
✓ Branch 0 taken 87093 times.
✓ Branch 1 taken 2744759 times.
✓ Branch 2 taken 1750862 times.
✓ Branch 3 taken 591622 times.
✗ Branch 4 not taken.
 5174336 switch (optype) {
4231
3/4
✓ Branch 0 taken 75392 times.
✓ Branch 1 taken 11697 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 87093 case OP_DEREF:
4232 switch (ctx) {
4233 75392 case Load:
4234
2/2
✓ Branch 0 taken 122 times.
✓ Branch 1 taken 75270 times.
 75392 op = (c->u->u_ste->ste_type == ClassBlock) ? LOAD_CLASSDEREF : LOAD_DEREF;
4235 75392 break;
4236 11697 case Store: op = STORE_DEREF; break;
4237 4 case Del: op = DELETE_DEREF; break;
4238 }
4239 87093 break;
4240
3/4
✓ Branch 0 taken 2266610 times.
✓ Branch 1 taken 473647 times.
✓ Branch 2 taken 4502 times.
✗ Branch 3 not taken.
 2744759 case OP_FAST:
4241 switch (ctx) {
4242 2266610 case Load: op = LOAD_FAST; break;
4243 473647 case Store: op = STORE_FAST; break;
4244 4502 case Del: op = DELETE_FAST; break;
4245 }
4246
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2744759 times.
 2744759 ADDOP_N(c, op, mangled, varnames);
4247 2744759 return 1;
4248
3/4
✓ Branch 0 taken 1749889 times.
✓ Branch 1 taken 969 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 1750862 case OP_GLOBAL:
4249 switch (ctx) {
4250 1749889 case Load: op = LOAD_GLOBAL; break;
4251 969 case Store: op = STORE_GLOBAL; break;
4252 4 case Del: op = DELETE_GLOBAL; break;
4253 }
4254 1750862 break;
4255
3/4
✓ Branch 0 taken 225166 times.
✓ Branch 1 taken 366072 times.
✓ Branch 2 taken 384 times.
✗ Branch 3 not taken.
 591622 case OP_NAME:
4256 switch (ctx) {
4257 225166 case Load: op = LOAD_NAME; break;
4258 366072 case Store: op = STORE_NAME; break;
4259 384 case Del: op = DELETE_NAME; break;
4260 }
4261 591622 break;
4262 }
4263
4264 assert(op);
4265 2429577 arg = compiler_add_o(dict, mangled);
4266 2429577 Py_DECREF(mangled);
4267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2429577 times.
 2429577 if (arg < 0) {
4268 ✗ return 0;
4269 }
4270
2/2
✓ Branch 0 taken 1749889 times.
✓ Branch 1 taken 679688 times.
 2429577 if (op == LOAD_GLOBAL) {
4271 1749889 arg <<= 1;
4272 }
4273 2429577 return compiler_addop_i(c, op, arg, true);
4274 }
4275
4276 static int
4277 12787 compiler_boolop(struct compiler *c, expr_ty e)
4278 {
4279 basicblock *end;
4280 int jumpi;
4281 Py_ssize_t i, n;
4282 asdl_expr_seq *s;
4283
4284 assert(e->kind == BoolOp_kind);
4285
2/2
✓ Branch 0 taken 8321 times.
✓ Branch 1 taken 4466 times.
 12787 if (e->v.BoolOp.op == And)
4286 8321 jumpi = JUMP_IF_FALSE_OR_POP;
4287 else
4288 4466 jumpi = JUMP_IF_TRUE_OR_POP;
4289 12787 end = compiler_new_block(c);
4290
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12787 times.
 12787 if (end == NULL)
4291 ✗ return 0;
4292 12787 s = e->v.BoolOp.values;
4293
1/2
✓ Branch 0 taken 12787 times.
✗ Branch 1 not taken.
 12787 n = asdl_seq_LEN(s) - 1;
4294 assert(n >= 0);
4295
2/2
✓ Branch 0 taken 13687 times.
✓ Branch 1 taken 12787 times.
 26474 for (i = 0; i < n; ++i) {
4296
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13687 times.
 13687 VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i));
4297
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13687 times.
 13687 ADDOP_JUMP(c, jumpi, end);
4298 13687 basicblock *next = compiler_new_block(c);
4299
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13687 times.
 13687 if (next == NULL) {
4300 ✗ return 0;
4301 }
4302 13687 compiler_use_next_block(c, next);
4303 }
4304
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12787 times.
 12787 VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n));
4305 12787 compiler_use_next_block(c, end);
4306 12787 return 1;
4307 }
4308
4309 static int
4310 239396 starunpack_helper(struct compiler *c, asdl_expr_seq *elts, int pushed,
4311 int build, int add, int extend, int tuple)
4312 {
4313
2/2
✓ Branch 0 taken 225855 times.
✓ Branch 1 taken 13541 times.
 239396 Py_ssize_t n = asdl_seq_LEN(elts);
4314
4/4
✓ Branch 0 taken 126937 times.
✓ Branch 1 taken 112459 times.
✓ Branch 3 taken 10746 times.
✓ Branch 4 taken 116191 times.
 239396 if (n > 2 && are_all_items_const(elts, 0, n)) {
4315 10746 PyObject *folded = PyTuple_New(n);
4316
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10746 times.
 10746 if (folded == NULL) {
4317 ✗ return 0;
4318 }
4319 PyObject *val;
4320
2/2
✓ Branch 0 taken 91786 times.
✓ Branch 1 taken 10746 times.
 102532 for (Py_ssize_t i = 0; i < n; i++) {
4321 91786 val = ((expr_ty)asdl_seq_GET(elts, i))->v.Constant.value;
4322 91786 Py_INCREF(val);
4323 91786 PyTuple_SET_ITEM(folded, i, val);
4324 }
4325
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 10745 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 10746 if (tuple && !pushed) {
4326
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
 1 ADDOP_LOAD_CONST_NEW(c, folded);
4327 } else {
4328
2/2
✓ Branch 0 taken 187 times.
✓ Branch 1 taken 10558 times.
 10745 if (add == SET_ADD) {
4329 187 Py_SETREF(folded, PyFrozenSet_New(folded));
4330
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 187 times.
 187 if (folded == NULL) {
4331 ✗ return 0;
4332 }
4333 }
4334
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10745 times.
 10745 ADDOP_I(c, build, pushed);
4335
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 10745 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10745 times.
 10745 ADDOP_LOAD_CONST_NEW(c, folded);
4336
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10745 times.
 10745 ADDOP_I(c, extend, 1);
4337
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10745 times.
 10745 if (tuple) {
4338 ✗ ADDOP(c, LIST_TO_TUPLE);
4339 }
4340 }
4341 10746 return 1;
4342 }
4343
4344 228650 int big = n+pushed > STACK_USE_GUIDELINE;
4345 228650 int seen_star = 0;
4346
2/2
✓ Branch 0 taken 768347 times.
✓ Branch 1 taken 223658 times.
 992005 for (Py_ssize_t i = 0; i < n; i++) {
4347 768347 expr_ty elt = asdl_seq_GET(elts, i);
4348
2/2
✓ Branch 0 taken 4992 times.
✓ Branch 1 taken 763355 times.
 768347 if (elt->kind == Starred_kind) {
4349 4992 seen_star = 1;
4350 4992 break;
4351 }
4352 }
4353
4/4
✓ Branch 0 taken 223658 times.
✓ Branch 1 taken 4992 times.
✓ Branch 2 taken 223546 times.
✓ Branch 3 taken 112 times.
 228650 if (!seen_star && !big) {
4354
2/2
✓ Branch 0 taken 739384 times.
✓ Branch 1 taken 223546 times.
 962930 for (Py_ssize_t i = 0; i < n; i++) {
4355 739384 expr_ty elt = asdl_seq_GET(elts, i);
4356
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 739384 times.
 739384 VISIT(c, expr, elt);
4357 }
4358
2/2
✓ Branch 0 taken 168998 times.
✓ Branch 1 taken 54548 times.
 223546 if (tuple) {
4359
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 168998 times.
 168998 ADDOP_I(c, BUILD_TUPLE, n+pushed);
4360 } else {
4361
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 54548 times.
 54548 ADDOP_I(c, build, n+pushed);
4362 }
4363 223546 return 1;
4364 }
4365 5104 int sequence_built = 0;
4366
2/2
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 4992 times.
 5104 if (big) {
4367
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 112 times.
 112 ADDOP_I(c, build, pushed);
4368 112 sequence_built = 1;
4369 }
4370
2/2
✓ Branch 0 taken 29250 times.
✓ Branch 1 taken 5104 times.
 34354 for (Py_ssize_t i = 0; i < n; i++) {
4371 29250 expr_ty elt = asdl_seq_GET(elts, i);
4372
2/2
✓ Branch 0 taken 5157 times.
✓ Branch 1 taken 24093 times.
 29250 if (elt->kind == Starred_kind) {
4373
2/2
✓ Branch 0 taken 4992 times.
✓ Branch 1 taken 165 times.
 5157 if (sequence_built == 0) {
4374
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4992 times.
 4992 ADDOP_I(c, build, i+pushed);
4375 4992 sequence_built = 1;
4376 }
4377
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5157 times.
 5157 VISIT(c, expr, elt->v.Starred.value);
4378
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5157 times.
 5157 ADDOP_I(c, extend, 1);
4379 }
4380 else {
4381
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24093 times.
 24093 VISIT(c, expr, elt);
4382
2/2
✓ Branch 0 taken 15784 times.
✓ Branch 1 taken 8309 times.
 24093 if (sequence_built) {
4383
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15784 times.
 15784 ADDOP_I(c, add, 1);
4384 }
4385 }
4386 }
4387 assert(sequence_built);
4388
2/2
✓ Branch 0 taken 4919 times.
✓ Branch 1 taken 185 times.
 5104 if (tuple) {
4389
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4919 times.
 4919 ADDOP(c, LIST_TO_TUPLE);
4390 }
4391 5104 return 1;
4392 }
4393
4394 static int
4395 39437 unpack_helper(struct compiler *c, asdl_expr_seq *elts)
4396 {
4397
1/2
✓ Branch 0 taken 39437 times.
✗ Branch 1 not taken.
 39437 Py_ssize_t n = asdl_seq_LEN(elts);
4398 39437 int seen_star = 0;
4399
2/2
✓ Branch 0 taken 162641 times.
✓ Branch 1 taken 39437 times.
 202078 for (Py_ssize_t i = 0; i < n; i++) {
4400 162641 expr_ty elt = asdl_seq_GET(elts, i);
4401
3/4
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 162604 times.
✓ Branch 2 taken 37 times.
✗ Branch 3 not taken.
 162641 if (elt->kind == Starred_kind && !seen_star) {
4402
1/2
✓ Branch 0 taken 37 times.
✗ Branch 1 not taken.
 37 if ((i >= (1 << 8)) ||
4403
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37 times.
 37 (n-i-1 >= (INT_MAX >> 8)))
4404 ✗ return compiler_error(c,
4405 "too many expressions in "
4406 "star-unpacking assignment");
4407
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37 times.
 37 ADDOP_I(c, UNPACK_EX, (i + ((n-i-1) << 8)));
4408 37 seen_star = 1;
4409 }
4410
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 162604 times.
 162604 else if (elt->kind == Starred_kind) {
4411 ✗ return compiler_error(c,
4412 "multiple starred expressions in assignment");
4413 }
4414 }
4415
2/2
✓ Branch 0 taken 39400 times.
✓ Branch 1 taken 37 times.
 39437 if (!seen_star) {
4416
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 39400 times.
 39400 ADDOP_I(c, UNPACK_SEQUENCE, n);
4417 }
4418 39437 return 1;
4419 }
4420
4421 static int
4422 39437 assignment_helper(struct compiler *c, asdl_expr_seq *elts)
4423 {
4424
1/2
✓ Branch 0 taken 39437 times.
✗ Branch 1 not taken.
 39437 Py_ssize_t n = asdl_seq_LEN(elts);
4425
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 39437 times.
 39437 RETURN_IF_FALSE(unpack_helper(c, elts));
4426
2/2
✓ Branch 0 taken 162641 times.
✓ Branch 1 taken 39437 times.
 202078 for (Py_ssize_t i = 0; i < n; i++) {
4427 162641 expr_ty elt = asdl_seq_GET(elts, i);
4428
3/4
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 162604 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 162641 times.
 162641 VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value);
4429 }
4430 39437 return 1;
4431 }
4432
4433 static int
4434 64045 compiler_list(struct compiler *c, expr_ty e)
4435 {
4436 64045 asdl_expr_seq *elts = e->v.List.elts;
4437
2/2
✓ Branch 0 taken 176 times.
✓ Branch 1 taken 63869 times.
 64045 if (e->v.List.ctx == Store) {
4438 176 return assignment_helper(c, elts);
4439 }
4440
1/2
✓ Branch 0 taken 63869 times.
✗ Branch 1 not taken.
 63869 else if (e->v.List.ctx == Load) {
4441 63869 return starunpack_helper(c, elts, 0, BUILD_LIST,
4442 LIST_APPEND, LIST_EXTEND, 0);
4443 }
4444 else
4445 ✗ VISIT_SEQ(c, expr, elts);
4446 ✗ return 1;
4447 }
4448
4449 static int
4450 201684 compiler_tuple(struct compiler *c, expr_ty e)
4451 {
4452 201684 asdl_expr_seq *elts = e->v.Tuple.elts;
4453
2/2
✓ Branch 0 taken 39261 times.
✓ Branch 1 taken 162423 times.
 201684 if (e->v.Tuple.ctx == Store) {
4454 39261 return assignment_helper(c, elts);
4455 }
4456
2/2
✓ Branch 0 taken 162422 times.
✓ Branch 1 taken 1 times.
 162423 else if (e->v.Tuple.ctx == Load) {
4457 162422 return starunpack_helper(c, elts, 0, BUILD_LIST,
4458 LIST_APPEND, LIST_EXTEND, 1);
4459 }
4460 else
4461
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✓ Branch 3 taken 43 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 42 times.
✓ Branch 6 taken 1 times.
 43 VISIT_SEQ(c, expr, elts);
4462 1 return 1;
4463 }
4464
4465 static int
4466 1609 compiler_set(struct compiler *c, expr_ty e)
4467 {
4468 1609 return starunpack_helper(c, e->v.Set.elts, 0, BUILD_SET,
4469 SET_ADD, SET_UPDATE, 0);
4470 }
4471
4472 static int
4473 136036 are_all_items_const(asdl_expr_seq *seq, Py_ssize_t begin, Py_ssize_t end)
4474 {
4475 Py_ssize_t i;
4476
2/2
✓ Branch 0 taken 256516 times.
✓ Branch 1 taken 18472 times.
 274988 for (i = begin; i < end; i++) {
4477 256516 expr_ty key = (expr_ty)asdl_seq_GET(seq, i);
4478
3/4
✓ Branch 0 taken 256516 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 117564 times.
✓ Branch 3 taken 138952 times.
 256516 if (key == NULL || key->kind != Constant_kind)
4479 117564 return 0;
4480 }
4481 18472 return 1;
4482 }
4483
4484 static int
4485 20807 compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end)
4486 {
4487 20807 Py_ssize_t i, n = end - begin;
4488 PyObject *keys, *key;
4489 20807 int big = n*2 > STACK_USE_GUIDELINE;
4490
6/6
✓ Branch 0 taken 16033 times.
✓ Branch 1 taken 4774 times.
✓ Branch 2 taken 9099 times.
✓ Branch 3 taken 6934 times.
✓ Branch 5 taken 7726 times.
✓ Branch 6 taken 1373 times.
 20807 if (n > 1 && !big && are_all_items_const(e->v.Dict.keys, begin, end)) {
4491
2/2
✓ Branch 0 taken 36881 times.
✓ Branch 1 taken 7726 times.
 44607 for (i = begin; i < end; i++) {
4492
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 36881 times.
 36881 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i));
4493 }
4494 7726 keys = PyTuple_New(n);
4495
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7726 times.
 7726 if (keys == NULL) {
4496 ✗ return 0;
4497 }
4498
2/2
✓ Branch 0 taken 36881 times.
✓ Branch 1 taken 7726 times.
 44607 for (i = begin; i < end; i++) {
4499 36881 key = ((expr_ty)asdl_seq_GET(e->v.Dict.keys, i))->v.Constant.value;
4500 36881 Py_INCREF(key);
4501 36881 PyTuple_SET_ITEM(keys, i - begin, key);
4502 }
4503
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 7726 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7726 times.
 7726 ADDOP_LOAD_CONST_NEW(c, keys);
4504
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7726 times.
 7726 ADDOP_I(c, BUILD_CONST_KEY_MAP, n);
4505 7726 return 1;
4506 }
4507
2/2
✓ Branch 0 taken 6934 times.
✓ Branch 1 taken 6147 times.
 13081 if (big) {
4508
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6934 times.
 6934 ADDOP_I(c, BUILD_MAP, 0);
4509 }
4510
2/2
✓ Branch 0 taken 126940 times.
✓ Branch 1 taken 13081 times.
 140021 for (i = begin; i < end; i++) {
4511
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 126940 times.
 126940 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i));
4512
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 126940 times.
 126940 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i));
4513
2/2
✓ Branch 0 taken 117693 times.
✓ Branch 1 taken 9247 times.
 126940 if (big) {
4514
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 117693 times.
 117693 ADDOP_I(c, MAP_ADD, 1);
4515 }
4516 }
4517
2/2
✓ Branch 0 taken 6147 times.
✓ Branch 1 taken 6934 times.
 13081 if (!big) {
4518
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6147 times.
 6147 ADDOP_I(c, BUILD_MAP, n);
4519 }
4520 13081 return 1;
4521 }
4522
4523 static int
4524 19396 compiler_dict(struct compiler *c, expr_ty e)
4525 {
4526 Py_ssize_t i, n, elements;
4527 int have_dict;
4528 19396 int is_unpacking = 0;
4529
1/2
✓ Branch 0 taken 19396 times.
✗ Branch 1 not taken.
 19396 n = asdl_seq_LEN(e->v.Dict.values);
4530 19396 have_dict = 0;
4531 19396 elements = 0;
4532
2/2
✓ Branch 0 taken 164042 times.
✓ Branch 1 taken 19396 times.
 183438 for (i = 0; i < n; i++) {
4533 164042 is_unpacking = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i) == NULL;
4534
2/2
✓ Branch 0 taken 221 times.
✓ Branch 1 taken 163821 times.
 164042 if (is_unpacking) {
4535
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 153 times.
 221 if (elements) {
4536
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 68 times.
 68 if (!compiler_subdict(c, e, i - elements, i)) {
4537 ✗ return 0;
4538 }
4539
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 62 times.
 68 if (have_dict) {
4540
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADDOP_I(c, DICT_UPDATE, 1);
4541 }
4542 68 have_dict = 1;
4543 68 elements = 0;
4544 }
4545
2/2
✓ Branch 0 taken 99 times.
✓ Branch 1 taken 122 times.
 221 if (have_dict == 0) {
4546
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 99 times.
 99 ADDOP_I(c, BUILD_MAP, 0);
4547 99 have_dict = 1;
4548 }
4549
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 221 times.
 221 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i));
4550
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 221 times.
 221 ADDOP_I(c, DICT_UPDATE, 1);
4551 }
4552 else {
4553
2/2
✓ Branch 0 taken 6749 times.
✓ Branch 1 taken 157072 times.
 163821 if (elements*2 > STACK_USE_GUIDELINE) {
4554
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6749 times.
 6749 if (!compiler_subdict(c, e, i - elements, i + 1)) {
4555 ✗ return 0;
4556 }
4557
2/2
✓ Branch 0 taken 5069 times.
✓ Branch 1 taken 1680 times.
 6749 if (have_dict) {
4558
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5069 times.
 5069 ADDOP_I(c, DICT_UPDATE, 1);
4559 }
4560 6749 have_dict = 1;
4561 6749 elements = 0;
4562 }
4563 else {
4564 157072 elements++;
4565 }
4566 }
4567 }
4568
2/2
✓ Branch 0 taken 13990 times.
✓ Branch 1 taken 5406 times.
 19396 if (elements) {
4569
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13990 times.
 13990 if (!compiler_subdict(c, e, n - elements, n)) {
4570 ✗ return 0;
4571 }
4572
2/2
✓ Branch 0 taken 1692 times.
✓ Branch 1 taken 12298 times.
 13990 if (have_dict) {
4573
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1692 times.
 1692 ADDOP_I(c, DICT_UPDATE, 1);
4574 }
4575 13990 have_dict = 1;
4576 }
4577
2/2
✓ Branch 0 taken 5257 times.
✓ Branch 1 taken 14139 times.
 19396 if (!have_dict) {
4578
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5257 times.
 5257 ADDOP_I(c, BUILD_MAP, 0);
4579 }
4580 19396 return 1;
4581 }
4582
4583 static int
4584 169368 compiler_compare(struct compiler *c, expr_ty e)
4585 {
4586 Py_ssize_t i, n;
4587
4588
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 169368 times.
 169368 if (!check_compare(c, e)) {
4589 ✗ return 0;
4590 }
4591
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 169368 times.
 169368 VISIT(c, expr, e->v.Compare.left);
4592 assert(asdl_seq_LEN(e->v.Compare.ops) > 0);
4593
1/2
✓ Branch 0 taken 169368 times.
✗ Branch 1 not taken.
 169368 n = asdl_seq_LEN(e->v.Compare.ops) - 1;
4594
2/2
✓ Branch 0 taken 169296 times.
✓ Branch 1 taken 72 times.
 169368 if (n == 0) {
4595
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 169296 times.
 169296 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0));
4596
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 169296 times.
 169296 ADDOP_COMPARE(c, asdl_seq_GET(e->v.Compare.ops, 0));
4597 }
4598 else {
4599 72 basicblock *cleanup = compiler_new_block(c);
4600
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 if (cleanup == NULL)
4601 ✗ return 0;
4602
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 72 times.
 144 for (i = 0; i < n; i++) {
4603
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 VISIT(c, expr,
4604 (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
4605
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_I(c, SWAP, 2);
4606
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_I(c, COPY, 2);
4607
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_COMPARE(c, asdl_seq_GET(e->v.Compare.ops, i));
4608
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_JUMP(c, JUMP_IF_FALSE_OR_POP, cleanup);
4609 }
4610
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n));
4611
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_COMPARE(c, asdl_seq_GET(e->v.Compare.ops, n));
4612 72 basicblock *end = compiler_new_block(c);
4613
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 if (end == NULL)
4614 ✗ return 0;
4615
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_JUMP_NOLINE(c, JUMP, end);
4616 72 compiler_use_next_block(c, cleanup);
4617
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP_I(c, SWAP, 2);
4618
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
 72 ADDOP(c, POP_TOP);
4619 72 compiler_use_next_block(c, end);
4620 }
4621 169368 return 1;
4622 }
4623
4624 static PyTypeObject *
4625 132329 infer_type(expr_ty e)
4626 {
4627
5/9
✓ Branch 0 taken 5884 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 87121 times.
✓ Branch 8 taken 39319 times.
 132329 switch (e->kind) {
4628 5884 case Tuple_kind:
4629 5884 return &PyTuple_Type;
4630 2 case List_kind:
4631 case ListComp_kind:
4632 2 return &PyList_Type;
4633 ✗ case Dict_kind:
4634 case DictComp_kind:
4635 ✗ return &PyDict_Type;
4636 ✗ case Set_kind:
4637 case SetComp_kind:
4638 ✗ return &PySet_Type;
4639 ✗ case GeneratorExp_kind:
4640 ✗ return &PyGen_Type;
4641 ✗ case Lambda_kind:
4642 ✗ return &PyFunction_Type;
4643 3 case JoinedStr_kind:
4644 case FormattedValue_kind:
4645 3 return &PyUnicode_Type;
4646 87121 case Constant_kind:
4647 87121 return Py_TYPE(e->v.Constant.value);
4648 39319 default:
4649 39319 return NULL;
4650 }
4651 }
4652
4653 static int
4654 1119690 check_caller(struct compiler *c, expr_ty e)
4655 {
4656
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1119690 times.
 1119690 switch (e->kind) {
4657 ✗ case Constant_kind:
4658 case Tuple_kind:
4659 case List_kind:
4660 case ListComp_kind:
4661 case Dict_kind:
4662 case DictComp_kind:
4663 case Set_kind:
4664 case SetComp_kind:
4665 case GeneratorExp_kind:
4666 case JoinedStr_kind:
4667 case FormattedValue_kind:
4668 ✗ return compiler_warn(c, "'%.200s' object is not callable; "
4669 "perhaps you missed a comma?",
4670 ✗ infer_type(e)->tp_name);
4671 1119690 default:
4672 1119690 return 1;
4673 }
4674 }
4675
4676 static int
4677 132329 check_subscripter(struct compiler *c, expr_ty e)
4678 {
4679 PyObject *v;
4680
4681
2/3
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 132249 times.
 132329 switch (e->kind) {
4682 80 case Constant_kind:
4683 80 v = e->v.Constant.value;
4684
4/8
✓ Branch 0 taken 80 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 80 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 80 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 80 times.
✗ Branch 7 not taken.
 240 if (!(v == Py_None || v == Py_Ellipsis ||
4685
2/4
✓ Branch 3 taken 80 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 80 times.
✗ Branch 7 not taken.
 160 PyLong_Check(v) || PyFloat_Check(v) || PyComplex_Check(v) ||
4686
3/6
✓ Branch 2 taken 80 times.
✗ Branch 3 not taken.
✓ Branch 6 taken 80 times.
✗ Branch 7 not taken.
✓ Branch 10 taken 80 times.
✗ Branch 11 not taken.
 160 PyAnySet_Check(v)))
4687 {
4688 80 return 1;
4689 }
4690 /* fall through */
4691 case Set_kind:
4692 case SetComp_kind:
4693 case GeneratorExp_kind:
4694 case Lambda_kind:
4695 ✗ return compiler_warn(c, "'%.200s' object is not subscriptable; "
4696 "perhaps you missed a comma?",
4697 ✗ infer_type(e)->tp_name);
4698 132249 default:
4699 132249 return 1;
4700 }
4701 }
4702
4703 static int
4704 132329 check_index(struct compiler *c, expr_ty e, expr_ty s)
4705 {
4706 PyObject *v;
4707
4708 132329 PyTypeObject *index_type = infer_type(s);
4709
2/2
✓ Branch 0 taken 93010 times.
✓ Branch 1 taken 39319 times.
 132329 if (index_type == NULL
4710
2/2
✓ Branch 1 taken 16790 times.
✓ Branch 2 taken 76220 times.
 93010 || PyType_FastSubclass(index_type, Py_TPFLAGS_LONG_SUBCLASS)
4711
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16790 times.
 16790 || index_type == &PySlice_Type) {
4712 115539 return 1;
4713 }
4714
4715
1/3
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✓ Branch 2 taken 16790 times.
 16790 switch (e->kind) {
4716 ✗ case Constant_kind:
4717 ✗ v = e->v.Constant.value;
4718 ✗ if (!(PyUnicode_Check(v) || PyBytes_Check(v) || PyTuple_Check(v))) {
4719 ✗ return 1;
4720 }
4721 /* fall through */
4722 case Tuple_kind:
4723 case List_kind:
4724 case ListComp_kind:
4725 case JoinedStr_kind:
4726 case FormattedValue_kind:
4727 ✗ return compiler_warn(c, "%.200s indices must be integers or slices, "
4728 "not %.200s; "
4729 "perhaps you missed a comma?",
4730 ✗ infer_type(e)->tp_name,
4731 index_type->tp_name);
4732 16790 default:
4733 16790 return 1;
4734 }
4735 }
4736
4737 static int
4738 318261 is_import_originated(struct compiler *c, expr_ty e)
4739 {
4740 /* Check whether the global scope has an import named
4741 e, if it is a Name object. For not traversing all the
4742 scope stack every time this function is called, it will
4743 only check the global scope to determine whether something
4744 is imported or not. */
4745
4746
2/2
✓ Branch 0 taken 108453 times.
✓ Branch 1 taken 209808 times.
 318261 if (e->kind != Name_kind) {
4747 108453 return 0;
4748 }
4749
4750 209808 long flags = _PyST_GetSymbol(c->c_st->st_top, e->v.Name.id);
4751 209808 return flags & DEF_IMPORT;
4752 }
4753
4754 static void
4755 515888 update_location_to_match_attr(struct compiler *c, expr_ty meth)
4756 {
4757
2/2
✓ Branch 0 taken 4056 times.
✓ Branch 1 taken 511832 times.
 515888 if (meth->lineno != meth->end_lineno) {
4758 // Make start location match attribute
4759 4056 c->u->u_loc.lineno = meth->end_lineno;
4760 4056 c->u->u_loc.col_offset = meth->end_col_offset - (int)PyUnicode_GetLength(meth->v.Attribute.attr)-1;
4761 }
4762 515888 }
4763
4764 // Return 1 if the method call was optimized, -1 if not, and 0 on error.
4765 static int
4766 1377634 maybe_optimize_method_call(struct compiler *c, expr_ty e)
4767 {
4768 Py_ssize_t argsl, i, kwdsl;
4769 1377634 expr_ty meth = e->v.Call.func;
4770 1377634 asdl_expr_seq *args = e->v.Call.args;
4771 1377634 asdl_keyword_seq *kwds = e->v.Call.keywords;
4772
4773 /* Check that the call node is an attribute access */
4774
3/4
✓ Branch 0 taken 318261 times.
✓ Branch 1 taken 1059373 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 318261 times.
 1377634 if (meth->kind != Attribute_kind || meth->v.Attribute.ctx != Load) {
4775 1059373 return -1;
4776 }
4777
4778 /* Check that the base object is not something that is imported */
4779
2/2
✓ Branch 1 taken 55162 times.
✓ Branch 2 taken 263099 times.
 318261 if (is_import_originated(c, meth->v.Attribute.value)) {
4780 55162 return -1;
4781 }
4782
4783 /* Check that there aren't too many arguments */
4784
2/2
✓ Branch 0 taken 197175 times.
✓ Branch 1 taken 65924 times.
 263099 argsl = asdl_seq_LEN(args);
4785
2/2
✓ Branch 0 taken 17382 times.
✓ Branch 1 taken 245717 times.
 263099 kwdsl = asdl_seq_LEN(kwds);
4786
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 263098 times.
 263099 if (argsl + kwdsl + (kwdsl != 0) >= STACK_USE_GUIDELINE) {
4787 1 return -1;
4788 }
4789 /* Check that there are no *varargs types of arguments. */
4790
2/2
✓ Branch 0 taken 295453 times.
✓ Branch 1 taken 260628 times.
 556081 for (i = 0; i < argsl; i++) {
4791 295453 expr_ty elt = asdl_seq_GET(args, i);
4792
2/2
✓ Branch 0 taken 2470 times.
✓ Branch 1 taken 292983 times.
 295453 if (elt->kind == Starred_kind) {
4793 2470 return -1;
4794 }
4795 }
4796
4797
2/2
✓ Branch 0 taken 26449 times.
✓ Branch 1 taken 257944 times.
 284393 for (i = 0; i < kwdsl; i++) {
4798 26449 keyword_ty kw = asdl_seq_GET(kwds, i);
4799
2/2
✓ Branch 0 taken 2684 times.
✓ Branch 1 taken 23765 times.
 26449 if (kw->arg == NULL) {
4800 2684 return -1;
4801 }
4802 }
4803 /* Alright, we can optimize the code. */
4804
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 257944 times.
 257944 VISIT(c, expr, meth->v.Attribute.value);
4805 257944 SET_LOC(c, meth);
4806 257944 update_location_to_match_attr(c, meth);
4807
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 257944 times.
 257944 ADDOP_NAME(c, LOAD_METHOD, meth->v.Attribute.attr, names);
4808
5/6
✗ Branch 1 not taken.
✓ Branch 2 taken 289117 times.
✓ Branch 3 taken 482072 times.
✓ Branch 4 taken 64989 times.
✓ Branch 5 taken 289117 times.
✓ Branch 6 taken 257944 times.
 547061 VISIT_SEQ(c, expr, e->v.Call.args);
4809
4810
2/2
✓ Branch 0 taken 13900 times.
✓ Branch 1 taken 244044 times.
 257944 if (kwdsl) {
4811
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 22502 times.
✓ Branch 3 taken 36402 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 22502 times.
✓ Branch 6 taken 13900 times.
 36402 VISIT_SEQ(c, keyword, kwds);
4812
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13900 times.
 13900 if (!compiler_call_simple_kw_helper(c, kwds, kwdsl)) {
4813 ✗ return 0;
4814 };
4815 }
4816 257944 SET_LOC(c, e);
4817 257944 update_location_to_match_attr(c, meth);
4818
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 257944 times.
 257944 ADDOP_I(c, CALL, argsl + kwdsl);
4819 257944 return 1;
4820 }
4821
4822 static int
4823 2512528 validate_keywords(struct compiler *c, asdl_keyword_seq *keywords)
4824 {
4825
2/2
✓ Branch 0 taken 113920 times.
✓ Branch 1 taken 2398608 times.
 2512528 Py_ssize_t nkeywords = asdl_seq_LEN(keywords);
4826
2/2
✓ Branch 0 taken 211266 times.
✓ Branch 1 taken 2512528 times.
 2723794 for (Py_ssize_t i = 0; i < nkeywords; i++) {
4827 211266 keyword_ty key = ((keyword_ty)asdl_seq_GET(keywords, i));
4828
2/2
✓ Branch 0 taken 19876 times.
✓ Branch 1 taken 191390 times.
 211266 if (key->arg == NULL) {
4829 19876 continue;
4830 }
4831
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 191390 times.
 191390 if (forbidden_name(c, key->arg, Store)) {
4832 ✗ return -1;
4833 }
4834
2/2
✓ Branch 0 taken 300305 times.
✓ Branch 1 taken 191390 times.
 491695 for (Py_ssize_t j = i + 1; j < nkeywords; j++) {
4835 300305 keyword_ty other = ((keyword_ty)asdl_seq_GET(keywords, j));
4836
3/4
✓ Branch 0 taken 288775 times.
✓ Branch 1 taken 11530 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 288775 times.
 300305 if (other->arg && !PyUnicode_Compare(key->arg, other->arg)) {
4837 ✗ SET_LOC(c, other);
4838 ✗ compiler_error(c, "keyword argument repeated: %U", key->arg);
4839 ✗ return -1;
4840 }
4841 }
4842 }
4843 2512528 return 0;
4844 }
4845
4846 static int
4847 1377634 compiler_call(struct compiler *c, expr_ty e)
4848 {
4849
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1377634 times.
 1377634 if (validate_keywords(c, e->v.Call.keywords) == -1) {
4850 ✗ return 0;
4851 }
4852 1377634 int ret = maybe_optimize_method_call(c, e);
4853
2/2
✓ Branch 0 taken 257944 times.
✓ Branch 1 taken 1119690 times.
 1377634 if (ret >= 0) {
4854 257944 return ret;
4855 }
4856
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1119690 times.
 1119690 if (!check_caller(c, e->v.Call.func)) {
4857 ✗ return 0;
4858 }
4859 1119690 SET_LOC(c, e->v.Call.func);
4860
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1119690 times.
 1119690 ADDOP(c, PUSH_NULL);
4861 1119690 SET_LOC(c, e);
4862
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1119690 times.
 1119690 VISIT(c, expr, e->v.Call.func);
4863 1119690 return compiler_call_helper(c, 0,
4864 e->v.Call.args,
4865 e->v.Call.keywords);
4866 }
4867
4868 static int
4869 10984 compiler_joined_str(struct compiler *c, expr_ty e)
4870 {
4871
4872
1/2
✓ Branch 0 taken 10984 times.
✗ Branch 1 not taken.
 10984 Py_ssize_t value_count = asdl_seq_LEN(e->v.JoinedStr.values);
4873
2/2
✓ Branch 0 taken 233 times.
✓ Branch 1 taken 10751 times.
 10984 if (value_count > STACK_USE_GUIDELINE) {
4874 _Py_DECLARE_STR(empty, "");
4875
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 233 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 233 times.
 233 ADDOP_LOAD_CONST_NEW(c, &_Py_STR(empty));
4876
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 233 times.
 233 ADDOP_NAME(c, LOAD_METHOD, &_Py_ID(join), names);
4877
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 233 times.
 233 ADDOP_I(c, BUILD_LIST, 0);
4878
3/4
✓ Branch 0 taken 7456 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7223 times.
✓ Branch 3 taken 233 times.
 7456 for (Py_ssize_t i = 0; i < asdl_seq_LEN(e->v.JoinedStr.values); i++) {
4879
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7223 times.
 7223 VISIT(c, expr, asdl_seq_GET(e->v.JoinedStr.values, i));
4880
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7223 times.
 7223 ADDOP_I(c, LIST_APPEND, 1);
4881 }
4882
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 233 times.
 233 ADDOP_I(c, CALL, 1);
4883 }
4884 else {
4885
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 64840 times.
✓ Branch 3 taken 75591 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 64840 times.
✓ Branch 6 taken 10751 times.
 75591 VISIT_SEQ(c, expr, e->v.JoinedStr.values);
4886
3/4
✓ Branch 0 taken 10751 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10619 times.
✓ Branch 3 taken 132 times.
 10751 if (asdl_seq_LEN(e->v.JoinedStr.values) != 1) {
4887
2/4
✓ Branch 0 taken 10619 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 10619 times.
 10619 ADDOP_I(c, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values));
4888 }
4889 }
4890 10984 return 1;
4891 }
4892
4893 /* Used to implement f-strings. Format a single value. */
4894 static int
4895 33769 compiler_formatted_value(struct compiler *c, expr_ty e)
4896 {
4897 /* Our oparg encodes 2 pieces of information: the conversion
4898 character, and whether or not a format_spec was provided.
4899
4900 Convert the conversion char to 3 bits:
4901 : 000 0x0 FVC_NONE The default if nothing specified.
4902 !s : 001 0x1 FVC_STR
4903 !r : 010 0x2 FVC_REPR
4904 !a : 011 0x3 FVC_ASCII
4905
4906 next bit is whether or not we have a format spec:
4907 yes : 100 0x4
4908 no : 000 0x0
4909 */
4910
4911 33769 int conversion = e->v.FormattedValue.conversion;
4912 int oparg;
4913
4914 /* The expression to be formatted. */
4915
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33769 times.
 33769 VISIT(c, expr, e->v.FormattedValue.value);
4916
4917
4/5
✓ Branch 0 taken 10309 times.
✓ Branch 1 taken 20279 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 3180 times.
✗ Branch 4 not taken.
 33769 switch (conversion) {
4918 10309 case 's': oparg = FVC_STR; break;
4919 20279 case 'r': oparg = FVC_REPR; break;
4920 1 case 'a': oparg = FVC_ASCII; break;
4921 3180 case -1: oparg = FVC_NONE; break;
4922 ✗ default:
4923 ✗ PyErr_Format(PyExc_SystemError,
4924 "Unrecognized conversion character %d", conversion);
4925 ✗ return 0;
4926 }
4927
2/2
✓ Branch 0 taken 77 times.
✓ Branch 1 taken 33692 times.
 33769 if (e->v.FormattedValue.format_spec) {
4928 /* Evaluate the format spec, and update our opcode arg. */
4929
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 77 times.
 77 VISIT(c, expr, e->v.FormattedValue.format_spec);
4930 77 oparg |= FVS_HAVE_SPEC;
4931 }
4932
4933 /* And push our opcode and oparg */
4934
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33769 times.
 33769 ADDOP_I(c, FORMAT_VALUE, oparg);
4935
4936 33769 return 1;
4937 }
4938
4939 static int
4940 2448 compiler_subkwargs(struct compiler *c, asdl_keyword_seq *keywords, Py_ssize_t begin, Py_ssize_t end)
4941 {
4942 2448 Py_ssize_t i, n = end - begin;
4943 keyword_ty kw;
4944 PyObject *keys, *key;
4945 assert(n > 0);
4946 2448 int big = n*2 > STACK_USE_GUIDELINE;
4947
4/4
✓ Branch 0 taken 1102 times.
✓ Branch 1 taken 1346 times.
✓ Branch 2 taken 955 times.
✓ Branch 3 taken 147 times.
 2448 if (n > 1 && !big) {
4948
2/2
✓ Branch 0 taken 4704 times.
✓ Branch 1 taken 955 times.
 5659 for (i = begin; i < end; i++) {
4949 4704 kw = asdl_seq_GET(keywords, i);
4950
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4704 times.
 4704 VISIT(c, expr, kw->value);
4951 }
4952 955 keys = PyTuple_New(n);
4953
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 955 times.
 955 if (keys == NULL) {
4954 ✗ return 0;
4955 }
4956
2/2
✓ Branch 0 taken 4704 times.
✓ Branch 1 taken 955 times.
 5659 for (i = begin; i < end; i++) {
4957 4704 key = ((keyword_ty) asdl_seq_GET(keywords, i))->arg;
4958 4704 Py_INCREF(key);
4959 4704 PyTuple_SET_ITEM(keys, i - begin, key);
4960 }
4961
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 955 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 955 times.
 955 ADDOP_LOAD_CONST_NEW(c, keys);
4962
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 955 times.
 955 ADDOP_I(c, BUILD_CONST_KEY_MAP, n);
4963 955 return 1;
4964 }
4965
2/2
✓ Branch 0 taken 147 times.
✓ Branch 1 taken 1346 times.
 1493 if (big) {
4966
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 147 times.
 147 ADDOP_I_NOLINE(c, BUILD_MAP, 0);
4967 }
4968
2/2
✓ Branch 0 taken 5501 times.
✓ Branch 1 taken 1493 times.
 6994 for (i = begin; i < end; i++) {
4969 5501 kw = asdl_seq_GET(keywords, i);
4970
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5501 times.
 5501 ADDOP_LOAD_CONST(c, kw->arg);
4971
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5501 times.
 5501 VISIT(c, expr, kw->value);
4972
2/2
✓ Branch 0 taken 4155 times.
✓ Branch 1 taken 1346 times.
 5501 if (big) {
4973
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4155 times.
 4155 ADDOP_I_NOLINE(c, MAP_ADD, 1);
4974 }
4975 }
4976
2/2
✓ Branch 0 taken 1346 times.
✓ Branch 1 taken 147 times.
 1493 if (!big) {
4977
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1346 times.
 1346 ADDOP_I(c, BUILD_MAP, n);
4978 }
4979 1493 return 1;
4980 }
4981
4982 /* Used by compiler_call_helper and maybe_optimize_method_call to emit
4983 * KW_NAMES before CALL.
4984 * Returns 1 on success, 0 on error.
4985 */
4986 static int
4987 53704 compiler_call_simple_kw_helper(struct compiler *c,
4988 asdl_keyword_seq *keywords,
4989 Py_ssize_t nkwelts)
4990 {
4991 PyObject *names;
4992 53704 names = PyTuple_New(nkwelts);
4993
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 53704 times.
 53704 if (names == NULL) {
4994 ✗ return 0;
4995 }
4996
2/2
✓ Branch 0 taken 96859 times.
✓ Branch 1 taken 53704 times.
 150563 for (int i = 0; i < nkwelts; i++) {
4997 96859 keyword_ty kw = asdl_seq_GET(keywords, i);
4998 96859 Py_INCREF(kw->arg);
4999 96859 PyTuple_SET_ITEM(names, i, kw->arg);
5000 }
5001 53704 Py_ssize_t arg = compiler_add_const(c, names);
5002
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 53704 times.
 53704 if (arg < 0) {
5003 ✗ return 0;
5004 }
5005 53704 Py_DECREF(names);
5006
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 53704 times.
 53704 ADDOP_I(c, KW_NAMES, arg);
5007 53704 return 1;
5008 }
5009
5010
5011 /* shared code between compiler_call and compiler_class */
5012 static int
5013 1134894 compiler_call_helper(struct compiler *c,
5014 int n, /* Args already pushed */
5015 asdl_expr_seq *args,
5016 asdl_keyword_seq *keywords)
5017 {
5018 Py_ssize_t i, nseen, nelts, nkwelts;
5019
5020
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1134894 times.
 1134894 if (validate_keywords(c, keywords) == -1) {
5021 ✗ return 0;
5022 }
5023
5024
2/2
✓ Branch 0 taken 1094575 times.
✓ Branch 1 taken 40319 times.
 1134894 nelts = asdl_seq_LEN(args);
5025
2/2
✓ Branch 0 taken 50121 times.
✓ Branch 1 taken 1084773 times.
 1134894 nkwelts = asdl_seq_LEN(keywords);
5026
5027
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 1134741 times.
 1134894 if (nelts + nkwelts*2 > STACK_USE_GUIDELINE) {
5028 153 goto ex_call;
5029 }
5030
2/2
✓ Branch 0 taken 1648598 times.
✓ Branch 1 taken 1123857 times.
 2772455 for (i = 0; i < nelts; i++) {
5031 1648598 expr_ty elt = asdl_seq_GET(args, i);
5032
2/2
✓ Branch 0 taken 10884 times.
✓ Branch 1 taken 1637714 times.
 1648598 if (elt->kind == Starred_kind) {
5033 10884 goto ex_call;
5034 }
5035 }
5036
2/2
✓ Branch 0 taken 86545 times.
✓ Branch 1 taken 1117331 times.
 1203876 for (i = 0; i < nkwelts; i++) {
5037 86545 keyword_ty kw = asdl_seq_GET(keywords, i);
5038
2/2
✓ Branch 0 taken 6526 times.
✓ Branch 1 taken 80019 times.
 86545 if (kw->arg == NULL) {
5039 6526 goto ex_call;
5040 }
5041 }
5042
5043 /* No * or ** args, so can use faster calling sequence */
5044
2/2
✓ Branch 0 taken 1619706 times.
✓ Branch 1 taken 1117331 times.
 2737037 for (i = 0; i < nelts; i++) {
5045 1619706 expr_ty elt = asdl_seq_GET(args, i);
5046 assert(elt->kind != Starred_kind);
5047
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1619706 times.
 1619706 VISIT(c, expr, elt);
5048 }
5049
2/2
✓ Branch 0 taken 39804 times.
✓ Branch 1 taken 1077527 times.
 1117331 if (nkwelts) {
5050
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 74357 times.
✓ Branch 3 taken 114161 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 74357 times.
✓ Branch 6 taken 39804 times.
 114161 VISIT_SEQ(c, keyword, keywords);
5051
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 39804 times.
 39804 if (!compiler_call_simple_kw_helper(c, keywords, nkwelts)) {
5052 ✗ return 0;
5053 };
5054 }
5055
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1117331 times.
 1117331 ADDOP_I(c, CALL, n + nelts + nkwelts);
5056 1117331 return 1;
5057
5058 17563 ex_call:
5059
5060 /* Do positional arguments. */
5061
5/6
✓ Branch 0 taken 17563 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8550 times.
✓ Branch 3 taken 9013 times.
✓ Branch 4 taken 6067 times.
✓ Branch 5 taken 2483 times.
 17563 if (n ==0 && nelts == 1 && ((expr_ty)asdl_seq_GET(args, 0))->kind == Starred_kind) {
5062
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6067 times.
 6067 VISIT(c, expr, ((expr_ty)asdl_seq_GET(args, 0))->v.Starred.value);
5063 }
5064
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11496 times.
 11496 else if (starunpack_helper(c, args, n, BUILD_LIST,
5065 LIST_APPEND, LIST_EXTEND, 1) == 0) {
5066 ✗ return 0;
5067 }
5068 /* Then keyword arguments */
5069
2/2
✓ Branch 0 taken 10317 times.
✓ Branch 1 taken 7246 times.
 17563 if (nkwelts) {
5070 /* Has a new dict been pushed */
5071 10317 int have_dict = 0;
5072
5073 10317 nseen = 0; /* the number of keyword arguments on the stack following */
5074
2/2
✓ Branch 0 taken 20143 times.
✓ Branch 1 taken 10317 times.
 30460 for (i = 0; i < nkwelts; i++) {
5075 20143 keyword_ty kw = asdl_seq_GET(keywords, i);
5076
2/2
✓ Branch 0 taken 9938 times.
✓ Branch 1 taken 10205 times.
 20143 if (kw->arg == NULL) {
5077 /* A keyword argument unpacking. */
5078
2/2
✓ Branch 0 taken 2068 times.
✓ Branch 1 taken 7870 times.
 9938 if (nseen) {
5079
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2068 times.
 2068 if (!compiler_subkwargs(c, keywords, i - nseen, i)) {
5080 ✗ return 0;
5081 }
5082
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2068 times.
 2068 if (have_dict) {
5083 ✗ ADDOP_I(c, DICT_MERGE, 1);
5084 }
5085 2068 have_dict = 1;
5086 2068 nseen = 0;
5087 }
5088
2/2
✓ Branch 0 taken 7869 times.
✓ Branch 1 taken 2069 times.
 9938 if (!have_dict) {
5089
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7869 times.
 7869 ADDOP_I(c, BUILD_MAP, 0);
5090 7869 have_dict = 1;
5091 }
5092
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9938 times.
 9938 VISIT(c, expr, kw->value);
5093
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9938 times.
 9938 ADDOP_I(c, DICT_MERGE, 1);
5094 }
5095 else {
5096 10205 nseen++;
5097 }
5098 }
5099
2/2
✓ Branch 0 taken 380 times.
✓ Branch 1 taken 9937 times.
 10317 if (nseen) {
5100 /* Pack up any trailing keyword arguments. */
5101
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 380 times.
 380 if (!compiler_subkwargs(c, keywords, nkwelts - nseen, nkwelts)) {
5102 ✗ return 0;
5103 }
5104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380 times.
 380 if (have_dict) {
5105 ✗ ADDOP_I(c, DICT_MERGE, 1);
5106 }
5107 380 have_dict = 1;
5108 }
5109 assert(have_dict);
5110 }
5111
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 17563 times.
 17563 ADDOP_I(c, CALL_FUNCTION_EX, nkwelts > 0);
5112 17563 return 1;
5113 }
5114
5115
5116 /* List and set comprehensions and generator expressions work by creating a
5117 nested function to perform the actual iteration. This means that the
5118 iteration variables don't leak into the current scope.
5119 The defined function is called immediately following its definition, with the
5120 result of that call being the result of the expression.
5121 The LC/SC version returns the populated container, while the GE version is
5122 flagged in symtable.c as a generator, so it returns the generator object
5123 when the function is called.
5124
5125 Possible cleanups:
5126 - iterate over the generator sequence instead of using recursion
5127 */
5128
5129
5130 static int
5131 16504 compiler_comprehension_generator(struct compiler *c,
5132 asdl_comprehension_seq *generators, int gen_index,
5133 int depth,
5134 expr_ty elt, expr_ty val, int type)
5135 {
5136 comprehension_ty gen;
5137 16504 gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
5138
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16504 times.
 16504 if (gen->is_async) {
5139 ✗ return compiler_async_comprehension_generator(
5140 c, generators, gen_index, depth, elt, val, type);
5141 } else {
5142 16504 return compiler_sync_comprehension_generator(
5143 c, generators, gen_index, depth, elt, val, type);
5144 }
5145 }
5146
5147 static int
5148 16504 compiler_sync_comprehension_generator(struct compiler *c,
5149 asdl_comprehension_seq *generators, int gen_index,
5150 int depth,
5151 expr_ty elt, expr_ty val, int type)
5152 {
5153 /* generate code for the iterator, then each of the ifs,
5154 and then write to the element */
5155
5156 comprehension_ty gen;
5157 basicblock *start, *anchor, *if_cleanup;
5158 Py_ssize_t i, n;
5159
5160 16504 start = compiler_new_block(c);
5161 16504 if_cleanup = compiler_new_block(c);
5162 16504 anchor = compiler_new_block(c);
5163
5164
3/6
✓ Branch 0 taken 16504 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16504 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 16504 times.
 16504 if (start == NULL || if_cleanup == NULL || anchor == NULL) {
5165 ✗ return 0;
5166 }
5167
5168 16504 gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
5169
5170
2/2
✓ Branch 0 taken 16005 times.
✓ Branch 1 taken 499 times.
 16504 if (gen_index == 0) {
5171 /* Receive outermost iter as an implicit argument */
5172 16005 c->u->u_argcount = 1;
5173
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 ADDOP_I(c, LOAD_FAST, 0);
5174 }
5175 else {
5176 /* Sub-iter - calculate on the fly */
5177 /* Fast path for the temporary variable assignment idiom:
5178 for y in [f(x)]
5179 */
5180 asdl_expr_seq *elts;
5181
2/3
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 486 times.
 499 switch (gen->iter->kind) {
5182 ✗ case List_kind:
5183 ✗ elts = gen->iter->v.List.elts;
5184 ✗ break;
5185 13 case Tuple_kind:
5186 13 elts = gen->iter->v.Tuple.elts;
5187 13 break;
5188 486 default:
5189 486 elts = NULL;
5190 }
5191
3/4
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 486 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 13 times.
 499 if (asdl_seq_LEN(elts) == 1) {
5192 ✗ expr_ty elt = asdl_seq_GET(elts, 0);
5193 ✗ if (elt->kind != Starred_kind) {
5194 ✗ VISIT(c, expr, elt);
5195 ✗ start = NULL;
5196 }
5197 }
5198
1/2
✓ Branch 0 taken 499 times.
✗ Branch 1 not taken.
 499 if (start) {
5199
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 499 times.
 499 VISIT(c, expr, gen->iter);
5200
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 499 times.
 499 ADDOP(c, GET_ITER);
5201 }
5202 }
5203
1/2
✓ Branch 0 taken 16504 times.
✗ Branch 1 not taken.
 16504 if (start) {
5204 16504 depth++;
5205 16504 compiler_use_next_block(c, start);
5206
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16504 times.
 16504 ADDOP_JUMP(c, FOR_ITER, anchor);
5207 }
5208
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16504 times.
 16504 VISIT(c, expr, gen->target);
5209
5210 /* XXX this needs to be cleaned up...a lot! */
5211
1/2
✓ Branch 0 taken 16504 times.
✗ Branch 1 not taken.
 16504 n = asdl_seq_LEN(gen->ifs);
5212
2/2
✓ Branch 0 taken 2314 times.
✓ Branch 1 taken 16504 times.
 18818 for (i = 0; i < n; i++) {
5213 2314 expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i);
5214
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2314 times.
 2314 if (!compiler_jump_if(c, e, if_cleanup, 0))
5215 ✗ return 0;
5216 }
5217
5218
3/4
✓ Branch 0 taken 16504 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 499 times.
✓ Branch 3 taken 16005 times.
 16504 if (++gen_index < asdl_seq_LEN(generators))
5219
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 499 times.
 499 if (!compiler_comprehension_generator(c,
5220 generators, gen_index, depth,
5221 elt, val, type))
5222 ✗ return 0;
5223
5224 /* only append after the last for generator */
5225
3/4
✓ Branch 0 taken 16504 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
✓ Branch 3 taken 499 times.
 16504 if (gen_index >= asdl_seq_LEN(generators)) {
5226 /* comprehension specific code */
5227
4/5
✓ Branch 0 taken 5547 times.
✓ Branch 1 taken 9279 times.
✓ Branch 2 taken 351 times.
✓ Branch 3 taken 828 times.
✗ Branch 4 not taken.
 16005 switch (type) {
5228 5547 case COMP_GENEXP:
5229
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5547 times.
 5547 VISIT(c, expr, elt);
5230
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5547 times.
 5547 ADDOP_YIELD(c);
5231
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5547 times.
 5547 ADDOP(c, POP_TOP);
5232 5547 break;
5233 9279 case COMP_LISTCOMP:
5234
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9279 times.
 9279 VISIT(c, expr, elt);
5235
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9279 times.
 9279 ADDOP_I(c, LIST_APPEND, depth + 1);
5236 9279 break;
5237 351 case COMP_SETCOMP:
5238
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 351 times.
 351 VISIT(c, expr, elt);
5239
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 351 times.
 351 ADDOP_I(c, SET_ADD, depth + 1);
5240 351 break;
5241 828 case COMP_DICTCOMP:
5242 /* With '{k: v}', k is evaluated before v, so we do
5243 the same. */
5244
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 828 times.
 828 VISIT(c, expr, elt);
5245
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 828 times.
 828 VISIT(c, expr, val);
5246
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 828 times.
 828 ADDOP_I(c, MAP_ADD, depth + 1);
5247 828 break;
5248 ✗ default:
5249 ✗ return 0;
5250 }
5251 }
5252 16504 compiler_use_next_block(c, if_cleanup);
5253
1/2
✓ Branch 0 taken 16504 times.
✗ Branch 1 not taken.
 16504 if (start) {
5254
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16504 times.
 16504 ADDOP_JUMP(c, JUMP, start);
5255 16504 compiler_use_next_block(c, anchor);
5256 }
5257
5258 16504 return 1;
5259 }
5260
5261 static int
5262 ✗ compiler_async_comprehension_generator(struct compiler *c,
5263 asdl_comprehension_seq *generators, int gen_index,
5264 int depth,
5265 expr_ty elt, expr_ty val, int type)
5266 {
5267 comprehension_ty gen;
5268 basicblock *start, *if_cleanup, *except;
5269 Py_ssize_t i, n;
5270 ✗ start = compiler_new_block(c);
5271 ✗ except = compiler_new_block(c);
5272 ✗ if_cleanup = compiler_new_block(c);
5273
5274 ✗ if (start == NULL || if_cleanup == NULL || except == NULL) {
5275 ✗ return 0;
5276 }
5277
5278 ✗ gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
5279
5280 ✗ if (gen_index == 0) {
5281 /* Receive outermost iter as an implicit argument */
5282 ✗ c->u->u_argcount = 1;
5283 ✗ ADDOP_I(c, LOAD_FAST, 0);
5284 }
5285 else {
5286 /* Sub-iter - calculate on the fly */
5287 ✗ VISIT(c, expr, gen->iter);
5288 ✗ ADDOP(c, GET_AITER);
5289 }
5290
5291 ✗ compiler_use_next_block(c, start);
5292 /* Runtime will push a block here, so we need to account for that */
5293 ✗ if (!compiler_push_fblock(c, ASYNC_COMPREHENSION_GENERATOR, start,
5294 NULL, NULL)) {
5295 ✗ return 0;
5296 }
5297
5298 ✗ ADDOP_JUMP(c, SETUP_FINALLY, except);
5299 ✗ ADDOP(c, GET_ANEXT);
5300 ✗ ADDOP_LOAD_CONST(c, Py_None);
5301 ✗ ADD_YIELD_FROM(c, 1);
5302 ✗ ADDOP(c, POP_BLOCK);
5303 ✗ VISIT(c, expr, gen->target);
5304
5305 ✗ n = asdl_seq_LEN(gen->ifs);
5306 ✗ for (i = 0; i < n; i++) {
5307 ✗ expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i);
5308 ✗ if (!compiler_jump_if(c, e, if_cleanup, 0))
5309 ✗ return 0;
5310 }
5311
5312 ✗ depth++;
5313 ✗ if (++gen_index < asdl_seq_LEN(generators))
5314 ✗ if (!compiler_comprehension_generator(c,
5315 generators, gen_index, depth,
5316 elt, val, type))
5317 ✗ return 0;
5318
5319 /* only append after the last for generator */
5320 ✗ if (gen_index >= asdl_seq_LEN(generators)) {
5321 /* comprehension specific code */
5322 ✗ switch (type) {
5323 ✗ case COMP_GENEXP:
5324 ✗ VISIT(c, expr, elt);
5325 ✗ ADDOP_YIELD(c);
5326 ✗ ADDOP(c, POP_TOP);
5327 ✗ break;
5328 ✗ case COMP_LISTCOMP:
5329 ✗ VISIT(c, expr, elt);
5330 ✗ ADDOP_I(c, LIST_APPEND, depth + 1);
5331 ✗ break;
5332 ✗ case COMP_SETCOMP:
5333 ✗ VISIT(c, expr, elt);
5334 ✗ ADDOP_I(c, SET_ADD, depth + 1);
5335 ✗ break;
5336 ✗ case COMP_DICTCOMP:
5337 /* With '{k: v}', k is evaluated before v, so we do
5338 the same. */
5339 ✗ VISIT(c, expr, elt);
5340 ✗ VISIT(c, expr, val);
5341 ✗ ADDOP_I(c, MAP_ADD, depth + 1);
5342 ✗ break;
5343 ✗ default:
5344 ✗ return 0;
5345 }
5346 }
5347 ✗ compiler_use_next_block(c, if_cleanup);
5348 ✗ ADDOP_JUMP(c, JUMP, start);
5349
5350 ✗ compiler_pop_fblock(c, ASYNC_COMPREHENSION_GENERATOR, start);
5351
5352 ✗ compiler_use_next_block(c, except);
5353 //UNSET_LOC(c);
5354
5355 ✗ ADDOP(c, END_ASYNC_FOR);
5356
5357 ✗ return 1;
5358 }
5359
5360 static int
5361 16005 compiler_comprehension(struct compiler *c, expr_ty e, int type,
5362 identifier name, asdl_comprehension_seq *generators, expr_ty elt,
5363 expr_ty val)
5364 {
5365 16005 PyCodeObject *co = NULL;
5366 comprehension_ty outermost;
5367 16005 PyObject *qualname = NULL;
5368 16005 int scope_type = c->u->u_scope_type;
5369 16005 int is_async_generator = 0;
5370
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 16005 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 16005 int is_top_level_await = IS_TOP_LEVEL_AWAIT(c);
5371
5372 16005 outermost = (comprehension_ty) asdl_seq_GET(generators, 0);
5373
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 if (!compiler_enter_scope(c, name, COMPILER_SCOPE_COMPREHENSION,
5374 (void *)e, e->lineno))
5375 {
5376 ✗ goto error;
5377 }
5378 16005 SET_LOC(c, e);
5379
5380 16005 is_async_generator = c->u->u_ste->ste_coroutine;
5381
5382
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 16005 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 16005 if (is_async_generator && type != COMP_GENEXP &&
5383 ✗ scope_type != COMPILER_SCOPE_ASYNC_FUNCTION &&
5384 ✗ scope_type != COMPILER_SCOPE_COMPREHENSION &&
5385 !is_top_level_await)
5386 {
5387 ✗ compiler_error(c, "asynchronous comprehension outside of "
5388 "an asynchronous function");
5389 ✗ goto error_in_scope;
5390 }
5391
5392
2/2
✓ Branch 0 taken 10458 times.
✓ Branch 1 taken 5547 times.
 16005 if (type != COMP_GENEXP) {
5393 int op;
5394
3/4
✓ Branch 0 taken 9279 times.
✓ Branch 1 taken 351 times.
✓ Branch 2 taken 828 times.
✗ Branch 3 not taken.
 10458 switch (type) {
5395 9279 case COMP_LISTCOMP:
5396 9279 op = BUILD_LIST;
5397 9279 break;
5398 351 case COMP_SETCOMP:
5399 351 op = BUILD_SET;
5400 351 break;
5401 828 case COMP_DICTCOMP:
5402 828 op = BUILD_MAP;
5403 828 break;
5404 ✗ default:
5405 ✗ PyErr_Format(PyExc_SystemError,
5406 "unknown comprehension type %d", type);
5407 ✗ goto error_in_scope;
5408 }
5409
5410
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10458 times.
 10458 ADDOP_I(c, op, 0);
5411 }
5412
5413
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 if (!compiler_comprehension_generator(c, generators, 0, 0, elt,
5414 val, type))
5415 ✗ goto error_in_scope;
5416
5417
2/2
✓ Branch 0 taken 10458 times.
✓ Branch 1 taken 5547 times.
 16005 if (type != COMP_GENEXP) {
5418
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10458 times.
 10458 ADDOP(c, RETURN_VALUE);
5419 }
5420
5421 16005 co = assemble(c, 1);
5422 16005 qualname = c->u->u_qualname;
5423 16005 Py_INCREF(qualname);
5424 16005 compiler_exit_scope(c);
5425
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 16005 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 16005 if (is_top_level_await && is_async_generator){
5426 ✗ c->u->u_ste->ste_coroutine = 1;
5427 }
5428
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16005 times.
 16005 if (co == NULL)
5429 ✗ goto error;
5430
5431
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 if (!compiler_make_closure(c, co, 0, qualname)) {
5432 ✗ goto error;
5433 }
5434 16005 Py_DECREF(qualname);
5435 16005 Py_DECREF(co);
5436
5437
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 VISIT(c, expr, outermost->iter);
5438
5439
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16005 times.
 16005 if (outermost->is_async) {
5440 ✗ ADDOP(c, GET_AITER);
5441 } else {
5442
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 ADDOP(c, GET_ITER);
5443 }
5444
5445
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16005 times.
 16005 ADDOP_I(c, CALL, 0);
5446
5447
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 16005 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 16005 if (is_async_generator && type != COMP_GENEXP) {
5448 ✗ ADDOP_I(c, GET_AWAITABLE, 0);
5449 ✗ ADDOP_LOAD_CONST(c, Py_None);
5450 ✗ ADD_YIELD_FROM(c, 1);
5451 }
5452
5453 16005 return 1;
5454 ✗ error_in_scope:
5455 ✗ compiler_exit_scope(c);
5456 ✗ error:
5457 ✗ Py_XDECREF(qualname);
5458 ✗ Py_XDECREF(co);
5459 ✗ return 0;
5460 }
5461
5462 static int
5463 5547 compiler_genexp(struct compiler *c, expr_ty e)
5464 {
5465 assert(e->kind == GeneratorExp_kind);
5466 _Py_DECLARE_STR(anon_genexpr, "<genexpr>");
5467 5547 return compiler_comprehension(c, e, COMP_GENEXP, &_Py_STR(anon_genexpr),
5468 e->v.GeneratorExp.generators,
5469 e->v.GeneratorExp.elt, NULL);
5470 }
5471
5472 static int
5473 9279 compiler_listcomp(struct compiler *c, expr_ty e)
5474 {
5475 assert(e->kind == ListComp_kind);
5476 _Py_DECLARE_STR(anon_listcomp, "<listcomp>");
5477 9279 return compiler_comprehension(c, e, COMP_LISTCOMP, &_Py_STR(anon_listcomp),
5478 e->v.ListComp.generators,
5479 e->v.ListComp.elt, NULL);
5480 }
5481
5482 static int
5483 351 compiler_setcomp(struct compiler *c, expr_ty e)
5484 {
5485 assert(e->kind == SetComp_kind);
5486 _Py_DECLARE_STR(anon_setcomp, "<setcomp>");
5487 351 return compiler_comprehension(c, e, COMP_SETCOMP, &_Py_STR(anon_setcomp),
5488 e->v.SetComp.generators,
5489 e->v.SetComp.elt, NULL);
5490 }
5491
5492
5493 static int
5494 828 compiler_dictcomp(struct compiler *c, expr_ty e)
5495 {
5496 assert(e->kind == DictComp_kind);
5497 _Py_DECLARE_STR(anon_dictcomp, "<dictcomp>");
5498 828 return compiler_comprehension(c, e, COMP_DICTCOMP, &_Py_STR(anon_dictcomp),
5499 e->v.DictComp.generators,
5500 e->v.DictComp.key, e->v.DictComp.value);
5501 }
5502
5503
5504 static int
5505 96859 compiler_visit_keyword(struct compiler *c, keyword_ty k)
5506 {
5507
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 96859 times.
 96859 VISIT(c, expr, k->value);
5508 96859 return 1;
5509 }
5510
5511
5512 static int
5513 4362 compiler_with_except_finish(struct compiler *c, basicblock * cleanup) {
5514 4362 UNSET_LOC(c);
5515 4362 basicblock *suppress = compiler_new_block(c);
5516
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4362 times.
 4362 if (suppress == NULL) {
5517 ✗ return 0;
5518 }
5519
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP_JUMP(c, POP_JUMP_IF_TRUE, suppress);
5520
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP_I(c, RERAISE, 2);
5521 4362 compiler_use_next_block(c, suppress);
5522
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP(c, POP_TOP); /* exc_value */
5523
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP(c, POP_BLOCK);
5524
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP(c, POP_EXCEPT);
5525
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP(c, POP_TOP);
5526
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP(c, POP_TOP);
5527 4362 basicblock *exit = compiler_new_block(c);
5528
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4362 times.
 4362 if (exit == NULL) {
5529 ✗ return 0;
5530 }
5531
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 ADDOP_JUMP(c, JUMP, exit);
5532 4362 compiler_use_next_block(c, cleanup);
5533
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4362 times.
 4362 POP_EXCEPT_AND_RERAISE(c);
5534 4362 compiler_use_next_block(c, exit);
5535 4362 return 1;
5536 }
5537
5538 /*
5539 Implements the async with statement.
5540
5541 The semantics outlined in that PEP are as follows:
5542
5543 async with EXPR as VAR:
5544 BLOCK
5545
5546 It is implemented roughly as:
5547
5548 context = EXPR
5549 exit = context.__aexit__ # not calling it
5550 value = await context.__aenter__()
5551 try:
5552 VAR = value # if VAR present in the syntax
5553 BLOCK
5554 finally:
5555 if an exception was raised:
5556 exc = copy of (exception, instance, traceback)
5557 else:
5558 exc = (None, None, None)
5559 if not (await exit(*exc)):
5560 raise
5561 */
5562 static int
5563 14 compiler_async_with(struct compiler *c, stmt_ty s, int pos)
5564 {
5565 basicblock *block, *final, *exit, *cleanup;
5566 14 withitem_ty item = asdl_seq_GET(s->v.AsyncWith.items, pos);
5567
5568 assert(s->kind == AsyncWith_kind);
5569
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 14 if (IS_TOP_LEVEL_AWAIT(c)){
5570 ✗ c->u->u_ste->ste_coroutine = 1;
5571
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 } else if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION){
5572 ✗ return compiler_error(c, "'async with' outside async function");
5573 }
5574
5575 14 block = compiler_new_block(c);
5576 14 final = compiler_new_block(c);
5577 14 exit = compiler_new_block(c);
5578 14 cleanup = compiler_new_block(c);
5579
4/8
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 14 times.
 14 if (!block || !final || !exit || !cleanup)
5580 ✗ return 0;
5581
5582 /* Evaluate EXPR */
5583
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 VISIT(c, expr, item->context_expr);
5584
5585
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP(c, BEFORE_ASYNC_WITH);
5586
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_I(c, GET_AWAITABLE, 1);
5587
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_LOAD_CONST(c, Py_None);
5588
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADD_YIELD_FROM(c, 1);
5589
5590
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_JUMP(c, SETUP_WITH, final);
5591
5592 /* SETUP_WITH pushes a finally block. */
5593 14 compiler_use_next_block(c, block);
5594
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 if (!compiler_push_fblock(c, ASYNC_WITH, block, final, s)) {
5595 ✗ return 0;
5596 }
5597
5598
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 11 times.
 14 if (item->optional_vars) {
5599
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 VISIT(c, expr, item->optional_vars);
5600 }
5601 else {
5602 /* Discard result from context.__aenter__() */
5603
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 ADDOP(c, POP_TOP);
5604 }
5605
5606 14 pos++;
5607
2/4
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
 14 if (pos == asdl_seq_LEN(s->v.AsyncWith.items))
5608 /* BLOCK code */
5609
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 47 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 33 times.
✓ Branch 6 taken 14 times.
 47 VISIT_SEQ(c, stmt, s->v.AsyncWith.body)
5610 ✗ else if (!compiler_async_with(c, s, pos))
5611 ✗ return 0;
5612
5613 14 compiler_pop_fblock(c, ASYNC_WITH, block);
5614
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP(c, POP_BLOCK);
5615 /* End of body; start the cleanup */
5616
5617 /* For successful outcome:
5618 * call __exit__(None, None, None)
5619 */
5620 14 SET_LOC(c, s);
5621
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 if(!compiler_call_exit_with_nones(c))
5622 ✗ return 0;
5623
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_I(c, GET_AWAITABLE, 2);
5624
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_LOAD_CONST(c, Py_None);
5625
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADD_YIELD_FROM(c, 1);
5626
5627
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP(c, POP_TOP);
5628
5629
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_JUMP(c, JUMP, exit);
5630
5631 /* For exceptional outcome: */
5632 14 compiler_use_next_block(c, final);
5633
5634
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_JUMP(c, SETUP_CLEANUP, cleanup);
5635
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP(c, PUSH_EXC_INFO);
5636
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP(c, WITH_EXCEPT_START);
5637
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_I(c, GET_AWAITABLE, 2);
5638
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADDOP_LOAD_CONST(c, Py_None);
5639
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
 14 ADD_YIELD_FROM(c, 1);
5640 14 compiler_with_except_finish(c, cleanup);
5641
5642 14 compiler_use_next_block(c, exit);
5643 14 return 1;
5644 }
5645
5646
5647 /*
5648 Implements the with statement from PEP 343.
5649 with EXPR as VAR:
5650 BLOCK
5651 is implemented as:
5652 <code for EXPR>
5653 SETUP_WITH E
5654 <code to store to VAR> or POP_TOP
5655 <code for BLOCK>
5656 LOAD_CONST (None, None, None)
5657 CALL_FUNCTION_EX 0
5658 JUMP EXIT
5659 E: WITH_EXCEPT_START (calls EXPR.__exit__)
5660 POP_JUMP_IF_TRUE T:
5661 RERAISE
5662 T: POP_TOP (remove exception from stack)
5663 POP_EXCEPT
5664 POP_TOP
5665 EXIT:
5666 */
5667
5668 static int
5669 4348 compiler_with(struct compiler *c, stmt_ty s, int pos)
5670 {
5671 basicblock *block, *final, *exit, *cleanup;
5672 4348 withitem_ty item = asdl_seq_GET(s->v.With.items, pos);
5673
5674 assert(s->kind == With_kind);
5675
5676 4348 block = compiler_new_block(c);
5677 4348 final = compiler_new_block(c);
5678 4348 exit = compiler_new_block(c);
5679 4348 cleanup = compiler_new_block(c);
5680
4/8
✓ Branch 0 taken 4348 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4348 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4348 times.
 4348 if (!block || !final || !exit || !cleanup)
5681 ✗ return 0;
5682
5683 /* Evaluate EXPR */
5684
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 VISIT(c, expr, item->context_expr);
5685 /* Will push bound __exit__ */
5686
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP(c, BEFORE_WITH);
5687
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP_JUMP(c, SETUP_WITH, final);
5688
5689 /* SETUP_WITH pushes a finally block. */
5690 4348 compiler_use_next_block(c, block);
5691
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 if (!compiler_push_fblock(c, WITH, block, final, s)) {
5692 ✗ return 0;
5693 }
5694
5695
2/2
✓ Branch 0 taken 1960 times.
✓ Branch 1 taken 2388 times.
 4348 if (item->optional_vars) {
5696
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1960 times.
 1960 VISIT(c, expr, item->optional_vars);
5697 }
5698 else {
5699 /* Discard result from context.__enter__() */
5700
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2388 times.
 2388 ADDOP(c, POP_TOP);
5701 }
5702
5703 4348 pos++;
5704
3/4
✓ Branch 0 taken 4348 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4330 times.
✓ Branch 3 taken 18 times.
 4348 if (pos == asdl_seq_LEN(s->v.With.items))
5705 /* BLOCK code */
5706
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 9294 times.
✓ Branch 3 taken 13624 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 9294 times.
✓ Branch 6 taken 4330 times.
 13624 VISIT_SEQ(c, stmt, s->v.With.body)
5707
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
 18 else if (!compiler_with(c, s, pos))
5708 ✗ return 0;
5709
5710
5711 /* Mark all following code as artificial */
5712 4348 UNSET_LOC(c);
5713
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP(c, POP_BLOCK);
5714 4348 compiler_pop_fblock(c, WITH, block);
5715
5716 /* End of body; start the cleanup. */
5717
5718 /* For successful outcome:
5719 * call __exit__(None, None, None)
5720 */
5721 4348 SET_LOC(c, s);
5722
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 if (!compiler_call_exit_with_nones(c))
5723 ✗ return 0;
5724
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP(c, POP_TOP);
5725
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP_JUMP(c, JUMP, exit);
5726
5727 /* For exceptional outcome: */
5728 4348 compiler_use_next_block(c, final);
5729
5730
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP_JUMP(c, SETUP_CLEANUP, cleanup);
5731
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP(c, PUSH_EXC_INFO);
5732
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4348 times.
 4348 ADDOP(c, WITH_EXCEPT_START);
5733 4348 compiler_with_except_finish(c, cleanup);
5734
5735 4348 compiler_use_next_block(c, exit);
5736 4348 return 1;
5737 }
5738
5739 static int
5740 10270270 compiler_visit_expr1(struct compiler *c, expr_ty e)
5741 {
5742
26/28
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 12787 times.
✓ Branch 2 taken 1168328 times.
✓ Branch 3 taken 47921 times.
✓ Branch 4 taken 100164 times.
✓ Branch 5 taken 5964 times.
✓ Branch 6 taken 19396 times.
✓ Branch 7 taken 1609 times.
✓ Branch 8 taken 5547 times.
✓ Branch 9 taken 9279 times.
✓ Branch 10 taken 351 times.
✓ Branch 11 taken 828 times.
✓ Branch 12 taken 4712 times.
✓ Branch 13 taken 546 times.
✓ Branch 14 taken 1068 times.
✓ Branch 15 taken 169368 times.
✓ Branch 16 taken 1377634 times.
✓ Branch 17 taken 1549177 times.
✓ Branch 18 taken 10984 times.
✓ Branch 19 taken 33769 times.
✓ Branch 20 taken 517836 times.
✓ Branch 21 taken 154506 times.
✗ Branch 22 not taken.
✓ Branch 23 taken 11374 times.
✓ Branch 24 taken 4801369 times.
✓ Branch 25 taken 64045 times.
✓ Branch 26 taken 201684 times.
✗ Branch 27 not taken.
 10270270 switch (e->kind) {
5743 24 case NamedExpr_kind:
5744
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
 24 VISIT(c, expr, e->v.NamedExpr.value);
5745
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
 24 ADDOP_I(c, COPY, 1);
5746
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
 24 VISIT(c, expr, e->v.NamedExpr.target);
5747 24 break;
5748 12787 case BoolOp_kind:
5749 12787 return compiler_boolop(c, e);
5750 1168328 case BinOp_kind:
5751
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1168328 times.
 1168328 VISIT(c, expr, e->v.BinOp.left);
5752
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1168328 times.
 1168328 VISIT(c, expr, e->v.BinOp.right);
5753
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1168328 times.
 1168328 ADDOP_BINARY(c, e->v.BinOp.op);
5754 1168328 break;
5755 47921 case UnaryOp_kind:
5756
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 47921 times.
 47921 VISIT(c, expr, e->v.UnaryOp.operand);
5757
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 47921 times.
 47921 ADDOP(c, unaryop(e->v.UnaryOp.op));
5758 47921 break;
5759 100164 case Lambda_kind:
5760 100164 return compiler_lambda(c, e);
5761 5964 case IfExp_kind:
5762 5964 return compiler_ifexp(c, e);
5763 19396 case Dict_kind:
5764 19396 return compiler_dict(c, e);
5765 1609 case Set_kind:
5766 1609 return compiler_set(c, e);
5767 5547 case GeneratorExp_kind:
5768 5547 return compiler_genexp(c, e);
5769 9279 case ListComp_kind:
5770 9279 return compiler_listcomp(c, e);
5771 351 case SetComp_kind:
5772 351 return compiler_setcomp(c, e);
5773 828 case DictComp_kind:
5774 828 return compiler_dictcomp(c, e);
5775 4712 case Yield_kind:
5776
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4712 times.
 4712 if (c->u->u_ste->ste_type != FunctionBlock)
5777 ✗ return compiler_error(c, "'yield' outside function");
5778
2/2
✓ Branch 0 taken 4527 times.
✓ Branch 1 taken 185 times.
 4712 if (e->v.Yield.value) {
5779
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4527 times.
 4527 VISIT(c, expr, e->v.Yield.value);
5780 }
5781 else {
5782
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 185 times.
 185 ADDOP_LOAD_CONST(c, Py_None);
5783 }
5784
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4712 times.
 4712 ADDOP_YIELD(c);
5785 4712 break;
5786 546 case YieldFrom_kind:
5787
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 546 times.
 546 if (c->u->u_ste->ste_type != FunctionBlock)
5788 ✗ return compiler_error(c, "'yield' outside function");
5789
5790
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 546 times.
 546 if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION)
5791 ✗ return compiler_error(c, "'yield from' inside async function");
5792
5793
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 546 times.
 546 VISIT(c, expr, e->v.YieldFrom.value);
5794
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 546 times.
 546 ADDOP(c, GET_YIELD_FROM_ITER);
5795
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 546 times.
 546 ADDOP_LOAD_CONST(c, Py_None);
5796
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 546 times.
 546 ADD_YIELD_FROM(c, 0);
5797 546 break;
5798 1068 case Await_kind:
5799
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1068 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1068 if (!IS_TOP_LEVEL_AWAIT(c)){
5800
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1068 times.
 1068 if (c->u->u_ste->ste_type != FunctionBlock){
5801 ✗ return compiler_error(c, "'await' outside function");
5802 }
5803
5804
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1068 times.
 1068 if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION &&
5805 ✗ c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION){
5806 ✗ return compiler_error(c, "'await' outside async function");
5807 }
5808 }
5809
5810
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1068 times.
 1068 VISIT(c, expr, e->v.Await.value);
5811
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1068 times.
 1068 ADDOP_I(c, GET_AWAITABLE, 0);
5812
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1068 times.
 1068 ADDOP_LOAD_CONST(c, Py_None);
5813
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1068 times.
 1068 ADD_YIELD_FROM(c, 1);
5814 1068 break;
5815 169368 case Compare_kind:
5816 169368 return compiler_compare(c, e);
5817 1377634 case Call_kind:
5818 1377634 return compiler_call(c, e);
5819 1549177 case Constant_kind:
5820
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1549177 times.
 1549177 ADDOP_LOAD_CONST(c, e->v.Constant.value);
5821 1549177 break;
5822 10984 case JoinedStr_kind:
5823 10984 return compiler_joined_str(c, e);
5824 33769 case FormattedValue_kind:
5825 33769 return compiler_formatted_value(c, e);
5826 /* The following exprs can be assignment targets. */
5827 517836 case Attribute_kind:
5828
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 517836 times.
 517836 VISIT(c, expr, e->v.Attribute.value);
5829
3/4
✓ Branch 0 taken 448229 times.
✓ Branch 1 taken 69453 times.
✓ Branch 2 taken 154 times.
✗ Branch 3 not taken.
 517836 switch (e->v.Attribute.ctx) {
5830 448229 case Load:
5831 {
5832 448229 int old_lineno = c->u->u_loc.lineno;
5833 448229 c->u->u_loc.lineno = e->end_lineno;
5834
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448229 times.
 448229 ADDOP_NAME(c, LOAD_ATTR, e->v.Attribute.attr, names);
5835 448229 c->u->u_loc.lineno = old_lineno;
5836 448229 break;
5837 }
5838 69453 case Store:
5839
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 69453 times.
 69453 if (forbidden_name(c, e->v.Attribute.attr, e->v.Attribute.ctx)) {
5840 ✗ return 0;
5841 }
5842 69453 int old_lineno = c->u->u_loc.lineno;
5843 69453 c->u->u_loc.lineno = e->end_lineno;
5844
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 69453 times.
 69453 ADDOP_NAME(c, STORE_ATTR, e->v.Attribute.attr, names);
5845 69453 c->u->u_loc.lineno = old_lineno;
5846 69453 break;
5847 154 case Del:
5848
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 154 times.
 154 ADDOP_NAME(c, DELETE_ATTR, e->v.Attribute.attr, names);
5849 154 break;
5850 }
5851 517836 break;
5852 154506 case Subscript_kind:
5853 154506 return compiler_subscript(c, e);
5854 ✗ case Starred_kind:
5855 ✗ switch (e->v.Starred.ctx) {
5856 ✗ case Store:
5857 /* In all legitimate cases, the Starred node was already replaced
5858 * by compiler_list/compiler_tuple. XXX: is that okay? */
5859 ✗ return compiler_error(c,
5860 "starred assignment target must be in a list or tuple");
5861 ✗ default:
5862 ✗ return compiler_error(c,
5863 "can't use starred expression here");
5864 }
5865 break;
5866 11374 case Slice_kind:
5867 11374 return compiler_slice(c, e);
5868 4801369 case Name_kind:
5869 4801369 return compiler_nameop(c, e->v.Name.id, e->v.Name.ctx);
5870 /* child nodes of List and Tuple will have expr_context set */
5871 64045 case List_kind:
5872 64045 return compiler_list(c, e);
5873 201684 case Tuple_kind:
5874 201684 return compiler_tuple(c, e);
5875 }
5876 3289612 return 1;
5877 }
5878
5879 static int
5880 10270270 compiler_visit_expr(struct compiler *c, expr_ty e)
5881 {
5882 10270270 struct location old_loc = c->u->u_loc;
5883 10270270 SET_LOC(c, e);
5884 10270270 int res = compiler_visit_expr1(c, e);
5885 10270270 c->u->u_loc = old_loc;
5886 10270270 return res;
5887 }
5888
5889 static int
5890 15223 compiler_augassign(struct compiler *c, stmt_ty s)
5891 {
5892 assert(s->kind == AugAssign_kind);
5893 15223 expr_ty e = s->v.AugAssign.target;
5894
5895 15223 struct location old_loc = c->u->u_loc;
5896 15223 SET_LOC(c, e);
5897
5898
3/4
✓ Branch 0 taken 1866 times.
✓ Branch 1 taken 1931 times.
✓ Branch 2 taken 11426 times.
✗ Branch 3 not taken.
 15223 switch (e->kind) {
5899 1866 case Attribute_kind:
5900
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1866 times.
 1866 VISIT(c, expr, e->v.Attribute.value);
5901
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1866 times.
 1866 ADDOP_I(c, COPY, 1);
5902 1866 int old_lineno = c->u->u_loc.lineno;
5903 1866 c->u->u_loc.lineno = e->end_lineno;
5904
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1866 times.
 1866 ADDOP_NAME(c, LOAD_ATTR, e->v.Attribute.attr, names);
5905 1866 c->u->u_loc.lineno = old_lineno;
5906 1866 break;
5907 1931 case Subscript_kind:
5908
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 VISIT(c, expr, e->v.Subscript.value);
5909
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 VISIT(c, expr, e->v.Subscript.slice);
5910
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 ADDOP_I(c, COPY, 2);
5911
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 ADDOP_I(c, COPY, 2);
5912
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 ADDOP(c, BINARY_SUBSCR);
5913 1931 break;
5914 11426 case Name_kind:
5915
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11426 times.
 11426 if (!compiler_nameop(c, e->v.Name.id, Load))
5916 ✗ return 0;
5917 11426 break;
5918 ✗ default:
5919 ✗ PyErr_Format(PyExc_SystemError,
5920 "invalid node type (%d) for augmented assignment",
5921 ✗ e->kind);
5922 ✗ return 0;
5923 }
5924
5925 15223 c->u->u_loc = old_loc;
5926
5927
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15223 times.
 15223 VISIT(c, expr, s->v.AugAssign.value);
5928
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15223 times.
 15223 ADDOP_INPLACE(c, s->v.AugAssign.op);
5929
5930 15223 SET_LOC(c, e);
5931
5932
3/4
✓ Branch 0 taken 1866 times.
✓ Branch 1 taken 1931 times.
✓ Branch 2 taken 11426 times.
✗ Branch 3 not taken.
 15223 switch (e->kind) {
5933 1866 case Attribute_kind:
5934 1866 c->u->u_loc.lineno = e->end_lineno;
5935
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1866 times.
 1866 ADDOP_I(c, SWAP, 2);
5936
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1866 times.
 1866 ADDOP_NAME(c, STORE_ATTR, e->v.Attribute.attr, names);
5937 1866 break;
5938 1931 case Subscript_kind:
5939
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 ADDOP_I(c, SWAP, 3);
5940
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 ADDOP_I(c, SWAP, 2);
5941
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1931 times.
 1931 ADDOP(c, STORE_SUBSCR);
5942 1931 break;
5943 11426 case Name_kind:
5944 11426 return compiler_nameop(c, e->v.Name.id, Store);
5945 ✗ default:
5946 ✗ Py_UNREACHABLE();
5947 }
5948 3797 return 1;
5949 }
5950
5951 static int
5952 8 check_ann_expr(struct compiler *c, expr_ty e)
5953 {
5954
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
 8 VISIT(c, expr, e);
5955
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
 8 ADDOP(c, POP_TOP);
5956 8 return 1;
5957 }
5958
5959 static int
5960 452 check_annotation(struct compiler *c, stmt_ty s)
5961 {
5962 /* Annotations of complex targets does not produce anything
5963 under annotations future */
5964
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 446 times.
 452 if (c->c_future->ff_features & CO_FUTURE_ANNOTATIONS) {
5965 6 return 1;
5966 }
5967
5968 /* Annotations are only evaluated in a module or class. */
5969
1/2
✓ Branch 0 taken 446 times.
✗ Branch 1 not taken.
 446 if (c->u->u_scope_type == COMPILER_SCOPE_MODULE ||
5970
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 446 times.
 446 c->u->u_scope_type == COMPILER_SCOPE_CLASS) {
5971 ✗ return check_ann_expr(c, s->v.AnnAssign.annotation);
5972 }
5973 446 return 1;
5974 }
5975
5976 static int
5977 ✗ check_ann_subscr(struct compiler *c, expr_ty e)
5978 {
5979 /* We check that everything in a subscript is defined at runtime. */
5980 ✗ switch (e->kind) {
5981 ✗ case Slice_kind:
5982 ✗ if (e->v.Slice.lower && !check_ann_expr(c, e->v.Slice.lower)) {
5983 ✗ return 0;
5984 }
5985 ✗ if (e->v.Slice.upper && !check_ann_expr(c, e->v.Slice.upper)) {
5986 ✗ return 0;
5987 }
5988 ✗ if (e->v.Slice.step && !check_ann_expr(c, e->v.Slice.step)) {
5989 ✗ return 0;
5990 }
5991 ✗ return 1;
5992 ✗ case Tuple_kind: {
5993 /* extended slice */
5994 ✗ asdl_expr_seq *elts = e->v.Tuple.elts;
5995 ✗ Py_ssize_t i, n = asdl_seq_LEN(elts);
5996 ✗ for (i = 0; i < n; i++) {
5997 ✗ if (!check_ann_subscr(c, asdl_seq_GET(elts, i))) {
5998 ✗ return 0;
5999 }
6000 }
6001 ✗ return 1;
6002 }
6003 ✗ default:
6004 ✗ return check_ann_expr(c, e);
6005 }
6006 }
6007
6008 static int
6009 2553 compiler_annassign(struct compiler *c, stmt_ty s)
6010 {
6011 2553 expr_ty targ = s->v.AnnAssign.target;
6012 PyObject* mangled;
6013
6014 assert(s->kind == AnnAssign_kind);
6015
6016 /* We perform the actual assignment first. */
6017
2/2
✓ Branch 0 taken 1894 times.
✓ Branch 1 taken 659 times.
 2553 if (s->v.AnnAssign.value) {
6018
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1894 times.
 1894 VISIT(c, expr, s->v.AnnAssign.value);
6019
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1894 times.
 1894 VISIT(c, expr, targ);
6020 }
6021
2/4
✓ Branch 0 taken 2101 times.
✓ Branch 1 taken 452 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2553 switch (targ->kind) {
6022 2101 case Name_kind:
6023
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2101 times.
 2101 if (forbidden_name(c, targ->v.Name.id, Store))
6024 ✗ return 0;
6025 /* If we have a simple name in a module or class, store annotation. */
6026
1/2
✓ Branch 0 taken 2101 times.
✗ Branch 1 not taken.
 2101 if (s->v.AnnAssign.simple &&
6027
2/2
✓ Branch 0 taken 1779 times.
✓ Branch 1 taken 322 times.
 2101 (c->u->u_scope_type == COMPILER_SCOPE_MODULE ||
6028
2/2
✓ Branch 0 taken 1026 times.
✓ Branch 1 taken 753 times.
 1779 c->u->u_scope_type == COMPILER_SCOPE_CLASS)) {
6029
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1344 times.
 1348 if (c->c_future->ff_features & CO_FUTURE_ANNOTATIONS) {
6030
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 VISIT(c, annexpr, s->v.AnnAssign.annotation)
6031 }
6032 else {
6033
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1344 times.
 1344 VISIT(c, expr, s->v.AnnAssign.annotation);
6034 }
6035
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1348 times.
 1348 ADDOP_NAME(c, LOAD_NAME, &_Py_ID(__annotations__), names);
6036 1348 mangled = _Py_Mangle(c->u->u_private, targ->v.Name.id);
6037
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1348 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1348 times.
 1348 ADDOP_LOAD_CONST_NEW(c, mangled);
6038
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1348 times.
 1348 ADDOP(c, STORE_SUBSCR);
6039 }
6040 2101 break;
6041 452 case Attribute_kind:
6042
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 452 times.
 452 if (forbidden_name(c, targ->v.Attribute.attr, Store))
6043 ✗ return 0;
6044
3/4
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 444 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
 460 if (!s->v.AnnAssign.value &&
6045 8 !check_ann_expr(c, targ->v.Attribute.value)) {
6046 ✗ return 0;
6047 }
6048 452 break;
6049 ✗ case Subscript_kind:
6050 ✗ if (!s->v.AnnAssign.value &&
6051 ✗ (!check_ann_expr(c, targ->v.Subscript.value) ||
6052 ✗ !check_ann_subscr(c, targ->v.Subscript.slice))) {
6053 ✗ return 0;
6054 }
6055 ✗ break;
6056 ✗ default:
6057 ✗ PyErr_Format(PyExc_SystemError,
6058 "invalid node type (%d) for annotated assignment",
6059 ✗ targ->kind);
6060 ✗ return 0;
6061 }
6062 /* Annotation is evaluated last. */
6063
3/4
✓ Branch 0 taken 452 times.
✓ Branch 1 taken 2101 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 452 times.
 2553 if (!s->v.AnnAssign.simple && !check_annotation(c, s)) {
6064 ✗ return 0;
6065 }
6066 2553 return 1;
6067 }
6068
6069 /* Raises a SyntaxError and returns 0.
6070 If something goes wrong, a different exception may be raised.
6071 */
6072
6073 static int
6074 ✗ compiler_error(struct compiler *c, const char *format, ...)
6075 {
6076 va_list vargs;
6077 ✗ va_start(vargs, format);
6078 ✗ PyObject *msg = PyUnicode_FromFormatV(format, vargs);
6079 ✗ va_end(vargs);
6080 ✗ if (msg == NULL) {
6081 ✗ return 0;
6082 }
6083 ✗ PyObject *loc = PyErr_ProgramTextObject(c->c_filename, c->u->u_loc.lineno);
6084 ✗ if (loc == NULL) {
6085 ✗ Py_INCREF(Py_None);
6086 ✗ loc = Py_None;
6087 }
6088 ✗ struct location u_loc = c->u->u_loc;
6089 ✗ PyObject *args = Py_BuildValue("O(OiiOii)", msg, c->c_filename,
6090 ✗ u_loc.lineno, u_loc.col_offset + 1, loc,
6091 ✗ u_loc.end_lineno, u_loc.end_col_offset + 1);
6092 ✗ Py_DECREF(msg);
6093 ✗ if (args == NULL) {
6094 ✗ goto exit;
6095 }
6096 ✗ PyErr_SetObject(PyExc_SyntaxError, args);
6097 ✗ exit:
6098 ✗ Py_DECREF(loc);
6099 ✗ Py_XDECREF(args);
6100 ✗ return 0;
6101 }
6102
6103 /* Emits a SyntaxWarning and returns 1 on success.
6104 If a SyntaxWarning raised as error, replaces it with a SyntaxError
6105 and returns 0.
6106 */
6107 static int
6108 ✗ compiler_warn(struct compiler *c, const char *format, ...)
6109 {
6110 va_list vargs;
6111 ✗ va_start(vargs, format);
6112 ✗ PyObject *msg = PyUnicode_FromFormatV(format, vargs);
6113 ✗ va_end(vargs);
6114 ✗ if (msg == NULL) {
6115 ✗ return 0;
6116 }
6117 ✗ if (PyErr_WarnExplicitObject(PyExc_SyntaxWarning, msg, c->c_filename,
6118 ✗ c->u->u_loc.lineno, NULL, NULL) < 0)
6119 {
6120 ✗ if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
6121 /* Replace the SyntaxWarning exception with a SyntaxError
6122 to get a more accurate error report */
6123 ✗ PyErr_Clear();
6124 assert(PyUnicode_AsUTF8(msg) != NULL);
6125 ✗ compiler_error(c, PyUnicode_AsUTF8(msg));
6126 }
6127 ✗ Py_DECREF(msg);
6128 ✗ return 0;
6129 }
6130 ✗ Py_DECREF(msg);
6131 ✗ return 1;
6132 }
6133
6134 static int
6135 154506 compiler_subscript(struct compiler *c, expr_ty e)
6136 {
6137 154506 expr_context_ty ctx = e->v.Subscript.ctx;
6138 154506 int op = 0;
6139
6140
2/2
✓ Branch 0 taken 132329 times.
✓ Branch 1 taken 22177 times.
 154506 if (ctx == Load) {
6141
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 132329 times.
 132329 if (!check_subscripter(c, e->v.Subscript.value)) {
6142 ✗ return 0;
6143 }
6144
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 132329 times.
 132329 if (!check_index(c, e->v.Subscript.value, e->v.Subscript.slice)) {
6145 ✗ return 0;
6146 }
6147 }
6148
6149
3/4
✓ Branch 0 taken 132329 times.
✓ Branch 1 taken 21004 times.
✓ Branch 2 taken 1173 times.
✗ Branch 3 not taken.
 154506 switch (ctx) {
6150 132329 case Load: op = BINARY_SUBSCR; break;
6151 21004 case Store: op = STORE_SUBSCR; break;
6152 1173 case Del: op = DELETE_SUBSCR; break;
6153 }
6154 assert(op);
6155
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 154506 times.
 154506 VISIT(c, expr, e->v.Subscript.value);
6156
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 154506 times.
 154506 VISIT(c, expr, e->v.Subscript.slice);
6157
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 154506 times.
 154506 ADDOP(c, op);
6158 154506 return 1;
6159 }
6160
6161 static int
6162 11374 compiler_slice(struct compiler *c, expr_ty s)
6163 {
6164 11374 int n = 2;
6165 assert(s->kind == Slice_kind);
6166
6167 /* only handles the cases where BUILD_SLICE is emitted */
6168
2/2
✓ Branch 0 taken 6016 times.
✓ Branch 1 taken 5358 times.
 11374 if (s->v.Slice.lower) {
6169
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6016 times.
 6016 VISIT(c, expr, s->v.Slice.lower);
6170 }
6171 else {
6172
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5358 times.
 5358 ADDOP_LOAD_CONST(c, Py_None);
6173 }
6174
6175
2/2
✓ Branch 0 taken 5086 times.
✓ Branch 1 taken 6288 times.
 11374 if (s->v.Slice.upper) {
6176
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5086 times.
 5086 VISIT(c, expr, s->v.Slice.upper);
6177 }
6178 else {
6179
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6288 times.
 6288 ADDOP_LOAD_CONST(c, Py_None);
6180 }
6181
6182
2/2
✓ Branch 0 taken 455 times.
✓ Branch 1 taken 10919 times.
 11374 if (s->v.Slice.step) {
6183 455 n++;
6184
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 455 times.
 455 VISIT(c, expr, s->v.Slice.step);
6185 }
6186
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11374 times.
 11374 ADDOP_I(c, BUILD_SLICE, n);
6187 11374 return 1;
6188 }
6189
6190
6191 // PEP 634: Structural Pattern Matching
6192
6193 // To keep things simple, all compiler_pattern_* and pattern_helper_* routines
6194 // follow the convention of consuming TOS (the subject for the given pattern)
6195 // and calling jump_to_fail_pop on failure (no match).
6196
6197 // When calling into these routines, it's important that pc->on_top be kept
6198 // updated to reflect the current number of items that we are using on the top
6199 // of the stack: they will be popped on failure, and any name captures will be
6200 // stored *underneath* them on success. This lets us defer all names stores
6201 // until the *entire* pattern matches.
6202
6203 #define WILDCARD_CHECK(N) \
6204 ((N)->kind == MatchAs_kind && !(N)->v.MatchAs.name)
6205
6206 #define WILDCARD_STAR_CHECK(N) \
6207 ((N)->kind == MatchStar_kind && !(N)->v.MatchStar.name)
6208
6209 // Limit permitted subexpressions, even if the parser & AST validator let them through
6210 #define MATCH_VALUE_EXPR(N) \
6211 ((N)->kind == Constant_kind || (N)->kind == Attribute_kind)
6212
6213 // Allocate or resize pc->fail_pop to allow for n items to be popped on failure.
6214 static int
6215 6 ensure_fail_pop(struct compiler *c, pattern_context *pc, Py_ssize_t n)
6216 {
6217 6 Py_ssize_t size = n + 1;
6218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (size <= pc->fail_pop_size) {
6219 ✗ return 1;
6220 }
6221 6 Py_ssize_t needed = sizeof(basicblock*) * size;
6222 6 basicblock **resized = PyObject_Realloc(pc->fail_pop, needed);
6223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (resized == NULL) {
6224 ✗ PyErr_NoMemory();
6225 ✗ return 0;
6226 }
6227 6 pc->fail_pop = resized;
6228
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 6 times.
 16 while (pc->fail_pop_size < size) {
6229 basicblock *new_block;
6230
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
 10 RETURN_IF_FALSE(new_block = compiler_new_block(c));
6231 10 pc->fail_pop[pc->fail_pop_size++] = new_block;
6232 }
6233 6 return 1;
6234 }
6235
6236 // Use op to jump to the correct fail_pop block.
6237 static int
6238 5 jump_to_fail_pop(struct compiler *c, pattern_context *pc, int op)
6239 {
6240 // Pop any items on the top of the stack, plus any objects we were going to
6241 // capture on success:
6242 5 Py_ssize_t pops = pc->on_top + PyList_GET_SIZE(pc->stores);
6243
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
 5 RETURN_IF_FALSE(ensure_fail_pop(c, pc, pops));
6244
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
 5 ADDOP_JUMP(c, op, pc->fail_pop[pops]);
6245 5 return 1;
6246 }
6247
6248 // Build all of the fail_pop blocks and reset fail_pop.
6249 static int
6250 6 emit_and_reset_fail_pop(struct compiler *c, pattern_context *pc)
6251 {
6252
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!pc->fail_pop_size) {
6253 assert(pc->fail_pop == NULL);
6254 ✗ return 1;
6255 }
6256
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 6 times.
 10 while (--pc->fail_pop_size) {
6257 4 compiler_use_next_block(c, pc->fail_pop[pc->fail_pop_size]);
6258
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 if (!compiler_addop(c, POP_TOP, true)) {
6259 ✗ pc->fail_pop_size = 0;
6260 ✗ PyObject_Free(pc->fail_pop);
6261 ✗ pc->fail_pop = NULL;
6262 ✗ return 0;
6263 }
6264 }
6265 6 compiler_use_next_block(c, pc->fail_pop[0]);
6266 6 PyObject_Free(pc->fail_pop);
6267 6 pc->fail_pop = NULL;
6268 6 return 1;
6269 }
6270
6271 static int
6272 ✗ compiler_error_duplicate_store(struct compiler *c, identifier n)
6273 {
6274 ✗ return compiler_error(c, "multiple assignments to name %R in pattern", n);
6275 }
6276
6277 // Duplicate the effect of 3.10's ROT_* instructions using SWAPs.
6278 static int
6279 3 pattern_helper_rotate(struct compiler *c, Py_ssize_t count)
6280 {
6281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 while (1 < count) {
6282 ✗ ADDOP_I(c, SWAP, count--);
6283 }
6284 3 return 1;
6285 }
6286
6287 static int
6288 3 pattern_helper_store_name(struct compiler *c, identifier n, pattern_context *pc)
6289 {
6290
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (n == NULL) {
6291 ✗ ADDOP(c, POP_TOP);
6292 ✗ return 1;
6293 }
6294
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (forbidden_name(c, n, Store)) {
6295 ✗ return 0;
6296 }
6297 // Can't assign to the same name twice:
6298 3 int duplicate = PySequence_Contains(pc->stores, n);
6299
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (duplicate < 0) {
6300 ✗ return 0;
6301 }
6302
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (duplicate) {
6303 ✗ return compiler_error_duplicate_store(c, n);
6304 }
6305 // Rotate this object underneath any items we need to preserve:
6306 3 Py_ssize_t rotations = pc->on_top + PyList_GET_SIZE(pc->stores) + 1;
6307
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 RETURN_IF_FALSE(pattern_helper_rotate(c, rotations));
6308 3 return !PyList_Append(pc->stores, n);
6309 }
6310
6311
6312 static int
6313 ✗ pattern_unpack_helper(struct compiler *c, asdl_pattern_seq *elts)
6314 {
6315 ✗ Py_ssize_t n = asdl_seq_LEN(elts);
6316 ✗ int seen_star = 0;
6317 ✗ for (Py_ssize_t i = 0; i < n; i++) {
6318 ✗ pattern_ty elt = asdl_seq_GET(elts, i);
6319 ✗ if (elt->kind == MatchStar_kind && !seen_star) {
6320 ✗ if ((i >= (1 << 8)) ||
6321 ✗ (n-i-1 >= (INT_MAX >> 8)))
6322 ✗ return compiler_error(c,
6323 "too many expressions in "
6324 "star-unpacking sequence pattern");
6325 ✗ ADDOP_I(c, UNPACK_EX, (i + ((n-i-1) << 8)));
6326 ✗ seen_star = 1;
6327 }
6328 ✗ else if (elt->kind == MatchStar_kind) {
6329 ✗ return compiler_error(c,
6330 "multiple starred expressions in sequence pattern");
6331 }
6332 }
6333 ✗ if (!seen_star) {
6334 ✗ ADDOP_I(c, UNPACK_SEQUENCE, n);
6335 }
6336 ✗ return 1;
6337 }
6338
6339 static int
6340 ✗ pattern_helper_sequence_unpack(struct compiler *c, asdl_pattern_seq *patterns,
6341 Py_ssize_t star, pattern_context *pc)
6342 {
6343 ✗ RETURN_IF_FALSE(pattern_unpack_helper(c, patterns));
6344 ✗ Py_ssize_t size = asdl_seq_LEN(patterns);
6345 // We've now got a bunch of new subjects on the stack. They need to remain
6346 // there after each subpattern match:
6347 ✗ pc->on_top += size;
6348 ✗ for (Py_ssize_t i = 0; i < size; i++) {
6349 // One less item to keep track of each time we loop through:
6350 ✗ pc->on_top--;
6351 ✗ pattern_ty pattern = asdl_seq_GET(patterns, i);
6352 ✗ RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
6353 }
6354 ✗ return 1;
6355 }
6356
6357 // Like pattern_helper_sequence_unpack, but uses BINARY_SUBSCR instead of
6358 // UNPACK_SEQUENCE / UNPACK_EX. This is more efficient for patterns with a
6359 // starred wildcard like [first, *_] / [first, *_, last] / [*_, last] / etc.
6360 static int
6361 ✗ pattern_helper_sequence_subscr(struct compiler *c, asdl_pattern_seq *patterns,
6362 Py_ssize_t star, pattern_context *pc)
6363 {
6364 // We need to keep the subject around for extracting elements:
6365 ✗ pc->on_top++;
6366 ✗ Py_ssize_t size = asdl_seq_LEN(patterns);
6367 ✗ for (Py_ssize_t i = 0; i < size; i++) {
6368 ✗ pattern_ty pattern = asdl_seq_GET(patterns, i);
6369 ✗ if (WILDCARD_CHECK(pattern)) {
6370 ✗ continue;
6371 }
6372 ✗ if (i == star) {
6373 assert(WILDCARD_STAR_CHECK(pattern));
6374 ✗ continue;
6375 }
6376 ✗ ADDOP_I(c, COPY, 1);
6377 ✗ if (i < star) {
6378 ✗ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(i));
6379 }
6380 else {
6381 // The subject may not support negative indexing! Compute a
6382 // nonnegative index:
6383 ✗ ADDOP(c, GET_LEN);
6384 ✗ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size - i));
6385 ✗ ADDOP_BINARY(c, Sub);
6386 }
6387 ✗ ADDOP(c, BINARY_SUBSCR);
6388 ✗ RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
6389 }
6390 // Pop the subject, we're done with it:
6391 ✗ pc->on_top--;
6392 ✗ ADDOP(c, POP_TOP);
6393 ✗ return 1;
6394 }
6395
6396 // Like compiler_pattern, but turn off checks for irrefutability.
6397 static int
6398 2 compiler_pattern_subpattern(struct compiler *c, pattern_ty p, pattern_context *pc)
6399 {
6400 2 int allow_irrefutable = pc->allow_irrefutable;
6401 2 pc->allow_irrefutable = 1;
6402
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 RETURN_IF_FALSE(compiler_pattern(c, p, pc));
6403 2 pc->allow_irrefutable = allow_irrefutable;
6404 2 return 1;
6405 }
6406
6407 static int
6408 3 compiler_pattern_as(struct compiler *c, pattern_ty p, pattern_context *pc)
6409 {
6410 assert(p->kind == MatchAs_kind);
6411
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (p->v.MatchAs.pattern == NULL) {
6412 // An irrefutable match:
6413
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (!pc->allow_irrefutable) {
6414 ✗ if (p->v.MatchAs.name) {
6415 ✗ const char *e = "name capture %R makes remaining patterns unreachable";
6416 ✗ return compiler_error(c, e, p->v.MatchAs.name);
6417 }
6418 ✗ const char *e = "wildcard makes remaining patterns unreachable";
6419 ✗ return compiler_error(c, e);
6420 }
6421 3 return pattern_helper_store_name(c, p->v.MatchAs.name, pc);
6422 }
6423 // Need to make a copy for (possibly) storing later:
6424 ✗ pc->on_top++;
6425 ✗ ADDOP_I(c, COPY, 1);
6426 ✗ RETURN_IF_FALSE(compiler_pattern(c, p->v.MatchAs.pattern, pc));
6427 // Success! Store it:
6428 ✗ pc->on_top--;
6429 ✗ RETURN_IF_FALSE(pattern_helper_store_name(c, p->v.MatchAs.name, pc));
6430 ✗ return 1;
6431 }
6432
6433 static int
6434 ✗ compiler_pattern_star(struct compiler *c, pattern_ty p, pattern_context *pc)
6435 {
6436 assert(p->kind == MatchStar_kind);
6437 ✗ RETURN_IF_FALSE(pattern_helper_store_name(c, p->v.MatchStar.name, pc));
6438 ✗ return 1;
6439 }
6440
6441 static int
6442 ✗ validate_kwd_attrs(struct compiler *c, asdl_identifier_seq *attrs, asdl_pattern_seq* patterns)
6443 {
6444 // Any errors will point to the pattern rather than the arg name as the
6445 // parser is only supplying identifiers rather than Name or keyword nodes
6446 ✗ Py_ssize_t nattrs = asdl_seq_LEN(attrs);
6447 ✗ for (Py_ssize_t i = 0; i < nattrs; i++) {
6448 ✗ identifier attr = ((identifier)asdl_seq_GET(attrs, i));
6449 ✗ SET_LOC(c, ((pattern_ty) asdl_seq_GET(patterns, i)));
6450 ✗ if (forbidden_name(c, attr, Store)) {
6451 ✗ return -1;
6452 }
6453 ✗ for (Py_ssize_t j = i + 1; j < nattrs; j++) {
6454 ✗ identifier other = ((identifier)asdl_seq_GET(attrs, j));
6455 ✗ if (!PyUnicode_Compare(attr, other)) {
6456 ✗ SET_LOC(c, ((pattern_ty) asdl_seq_GET(patterns, j)));
6457 ✗ compiler_error(c, "attribute name repeated in class pattern: %U", attr);
6458 ✗ return -1;
6459 }
6460 }
6461 }
6462 ✗ return 0;
6463 }
6464
6465 static int
6466 4 compiler_pattern_class(struct compiler *c, pattern_ty p, pattern_context *pc)
6467 {
6468 assert(p->kind == MatchClass_kind);
6469 4 asdl_pattern_seq *patterns = p->v.MatchClass.patterns;
6470 4 asdl_identifier_seq *kwd_attrs = p->v.MatchClass.kwd_attrs;
6471 4 asdl_pattern_seq *kwd_patterns = p->v.MatchClass.kwd_patterns;
6472
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 Py_ssize_t nargs = asdl_seq_LEN(patterns);
6473
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 Py_ssize_t nattrs = asdl_seq_LEN(kwd_attrs);
6474
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 Py_ssize_t nkwd_patterns = asdl_seq_LEN(kwd_patterns);
6475
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (nattrs != nkwd_patterns) {
6476 // AST validator shouldn't let this happen, but if it does,
6477 // just fail, don't crash out of the interpreter
6478 ✗ const char * e = "kwd_attrs (%d) / kwd_patterns (%d) length mismatch in class pattern";
6479 ✗ return compiler_error(c, e, nattrs, nkwd_patterns);
6480 }
6481
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 4 if (INT_MAX < nargs || INT_MAX < nargs + nattrs - 1) {
6482 ✗ const char *e = "too many sub-patterns in class pattern %R";
6483 ✗ return compiler_error(c, e, p->v.MatchClass.cls);
6484 }
6485
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (nattrs) {
6486 ✗ RETURN_IF_FALSE(!validate_kwd_attrs(c, kwd_attrs, kwd_patterns));
6487 ✗ SET_LOC(c, p);
6488 }
6489
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 VISIT(c, expr, p->v.MatchClass.cls);
6490 PyObject *attr_names;
6491
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 RETURN_IF_FALSE(attr_names = PyTuple_New(nattrs));
6492 Py_ssize_t i;
6493
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 for (i = 0; i < nattrs; i++) {
6494 ✗ PyObject *name = asdl_seq_GET(kwd_attrs, i);
6495 ✗ Py_INCREF(name);
6496 ✗ PyTuple_SET_ITEM(attr_names, i, name);
6497 }
6498
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
 4 ADDOP_LOAD_CONST_NEW(c, attr_names);
6499
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 ADDOP_I(c, MATCH_CLASS, nargs);
6500
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 ADDOP_I(c, COPY, 1);
6501
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 ADDOP_LOAD_CONST(c, Py_None);
6502
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 ADDOP_I(c, IS_OP, 1);
6503 // TOS is now a tuple of (nargs + nattrs) attributes (or None):
6504 4 pc->on_top++;
6505
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6506
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 ADDOP_I(c, UNPACK_SEQUENCE, nargs + nattrs);
6507 4 pc->on_top += nargs + nattrs - 1;
6508
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
 6 for (i = 0; i < nargs + nattrs; i++) {
6509 2 pc->on_top--;
6510 pattern_ty pattern;
6511
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (i < nargs) {
6512 // Positional:
6513 2 pattern = asdl_seq_GET(patterns, i);
6514 }
6515 else {
6516 // Keyword:
6517 ✗ pattern = asdl_seq_GET(kwd_patterns, i - nargs);
6518 }
6519
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 if (WILDCARD_CHECK(pattern)) {
6520 ✗ ADDOP(c, POP_TOP);
6521 ✗ continue;
6522 }
6523
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
6524 }
6525 // Success! Pop the tuple of attributes:
6526 4 return 1;
6527 }
6528
6529 static int
6530 ✗ compiler_pattern_mapping(struct compiler *c, pattern_ty p, pattern_context *pc)
6531 {
6532 assert(p->kind == MatchMapping_kind);
6533 ✗ asdl_expr_seq *keys = p->v.MatchMapping.keys;
6534 ✗ asdl_pattern_seq *patterns = p->v.MatchMapping.patterns;
6535 ✗ Py_ssize_t size = asdl_seq_LEN(keys);
6536 ✗ Py_ssize_t npatterns = asdl_seq_LEN(patterns);
6537 ✗ if (size != npatterns) {
6538 // AST validator shouldn't let this happen, but if it does,
6539 // just fail, don't crash out of the interpreter
6540 ✗ const char * e = "keys (%d) / patterns (%d) length mismatch in mapping pattern";
6541 ✗ return compiler_error(c, e, size, npatterns);
6542 }
6543 // We have a double-star target if "rest" is set
6544 ✗ PyObject *star_target = p->v.MatchMapping.rest;
6545 // We need to keep the subject on top during the mapping and length checks:
6546 ✗ pc->on_top++;
6547 ✗ ADDOP(c, MATCH_MAPPING);
6548 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6549 ✗ if (!size && !star_target) {
6550 // If the pattern is just "{}", we're done! Pop the subject:
6551 ✗ pc->on_top--;
6552 ✗ ADDOP(c, POP_TOP);
6553 ✗ return 1;
6554 }
6555 ✗ if (size) {
6556 // If the pattern has any keys in it, perform a length check:
6557 ✗ ADDOP(c, GET_LEN);
6558 ✗ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size));
6559 ✗ ADDOP_COMPARE(c, GtE);
6560 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6561 }
6562 ✗ if (INT_MAX < size - 1) {
6563 ✗ return compiler_error(c, "too many sub-patterns in mapping pattern");
6564 }
6565 // Collect all of the keys into a tuple for MATCH_KEYS and
6566 // **rest. They can either be dotted names or literals:
6567
6568 // Maintaining a set of Constant_kind kind keys allows us to raise a
6569 // SyntaxError in the case of duplicates.
6570 ✗ PyObject *seen = PySet_New(NULL);
6571 ✗ if (seen == NULL) {
6572 ✗ return 0;
6573 }
6574
6575 // NOTE: goto error on failure in the loop below to avoid leaking `seen`
6576 ✗ for (Py_ssize_t i = 0; i < size; i++) {
6577 ✗ expr_ty key = asdl_seq_GET(keys, i);
6578 ✗ if (key == NULL) {
6579 ✗ const char *e = "can't use NULL keys in MatchMapping "
6580 "(set 'rest' parameter instead)";
6581 ✗ SET_LOC(c, ((pattern_ty) asdl_seq_GET(patterns, i)));
6582 ✗ compiler_error(c, e);
6583 ✗ goto error;
6584 }
6585
6586 ✗ if (key->kind == Constant_kind) {
6587 ✗ int in_seen = PySet_Contains(seen, key->v.Constant.value);
6588 ✗ if (in_seen < 0) {
6589 ✗ goto error;
6590 }
6591 ✗ if (in_seen) {
6592 ✗ const char *e = "mapping pattern checks duplicate key (%R)";
6593 ✗ compiler_error(c, e, key->v.Constant.value);
6594 ✗ goto error;
6595 }
6596 ✗ if (PySet_Add(seen, key->v.Constant.value)) {
6597 ✗ goto error;
6598 }
6599 }
6600
6601 ✗ else if (key->kind != Attribute_kind) {
6602 ✗ const char *e = "mapping pattern keys may only match literals and attribute lookups";
6603 ✗ compiler_error(c, e);
6604 ✗ goto error;
6605 }
6606 ✗ if (!compiler_visit_expr(c, key)) {
6607 ✗ goto error;
6608 }
6609 }
6610
6611 // all keys have been checked; there are no duplicates
6612 ✗ Py_DECREF(seen);
6613
6614 ✗ ADDOP_I(c, BUILD_TUPLE, size);
6615 ✗ ADDOP(c, MATCH_KEYS);
6616 // There's now a tuple of keys and a tuple of values on top of the subject:
6617 ✗ pc->on_top += 2;
6618 ✗ ADDOP_I(c, COPY, 1);
6619 ✗ ADDOP_LOAD_CONST(c, Py_None);
6620 ✗ ADDOP_I(c, IS_OP, 1);
6621 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6622 // So far so good. Use that tuple of values on the stack to match
6623 // sub-patterns against:
6624 ✗ ADDOP_I(c, UNPACK_SEQUENCE, size);
6625 ✗ pc->on_top += size - 1;
6626 ✗ for (Py_ssize_t i = 0; i < size; i++) {
6627 ✗ pc->on_top--;
6628 ✗ pattern_ty pattern = asdl_seq_GET(patterns, i);
6629 ✗ RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
6630 }
6631 // If we get this far, it's a match! Whatever happens next should consume
6632 // the tuple of keys and the subject:
6633 ✗ pc->on_top -= 2;
6634 ✗ if (star_target) {
6635 // If we have a starred name, bind a dict of remaining items to it (this may
6636 // seem a bit inefficient, but keys is rarely big enough to actually impact
6637 // runtime):
6638 // rest = dict(TOS1)
6639 // for key in TOS:
6640 // del rest[key]
6641 ✗ ADDOP_I(c, BUILD_MAP, 0); // [subject, keys, empty]
6642 ✗ ADDOP_I(c, SWAP, 3); // [empty, keys, subject]
6643 ✗ ADDOP_I(c, DICT_UPDATE, 2); // [copy, keys]
6644 ✗ ADDOP_I(c, UNPACK_SEQUENCE, size); // [copy, keys...]
6645 ✗ while (size) {
6646 ✗ ADDOP_I(c, COPY, 1 + size--); // [copy, keys..., copy]
6647 ✗ ADDOP_I(c, SWAP, 2); // [copy, keys..., copy, key]
6648 ✗ ADDOP(c, DELETE_SUBSCR); // [copy, keys...]
6649 }
6650 ✗ RETURN_IF_FALSE(pattern_helper_store_name(c, star_target, pc));
6651 }
6652 else {
6653 ✗ ADDOP(c, POP_TOP); // Tuple of keys.
6654 ✗ ADDOP(c, POP_TOP); // Subject.
6655 }
6656 ✗ return 1;
6657
6658 ✗ error:
6659 ✗ Py_DECREF(seen);
6660 ✗ return 0;
6661 }
6662
6663 static int
6664 ✗ compiler_pattern_or(struct compiler *c, pattern_ty p, pattern_context *pc)
6665 {
6666 assert(p->kind == MatchOr_kind);
6667 basicblock *end;
6668 ✗ RETURN_IF_FALSE(end = compiler_new_block(c));
6669 ✗ Py_ssize_t size = asdl_seq_LEN(p->v.MatchOr.patterns);
6670 assert(size > 1);
6671 // We're going to be messing with pc. Keep the original info handy:
6672 ✗ pattern_context old_pc = *pc;
6673 ✗ Py_INCREF(pc->stores);
6674 // control is the list of names bound by the first alternative. It is used
6675 // for checking different name bindings in alternatives, and for correcting
6676 // the order in which extracted elements are placed on the stack.
6677 ✗ PyObject *control = NULL;
6678 // NOTE: We can't use returning macros anymore! goto error on error.
6679 ✗ for (Py_ssize_t i = 0; i < size; i++) {
6680 ✗ pattern_ty alt = asdl_seq_GET(p->v.MatchOr.patterns, i);
6681 ✗ SET_LOC(c, alt);
6682 ✗ PyObject *pc_stores = PyList_New(0);
6683 ✗ if (pc_stores == NULL) {
6684 ✗ goto error;
6685 }
6686 ✗ Py_SETREF(pc->stores, pc_stores);
6687 // An irrefutable sub-pattern must be last, if it is allowed at all:
6688 ✗ pc->allow_irrefutable = (i == size - 1) && old_pc.allow_irrefutable;
6689 ✗ pc->fail_pop = NULL;
6690 ✗ pc->fail_pop_size = 0;
6691 ✗ pc->on_top = 0;
6692 ✗ if (!compiler_addop_i(c, COPY, 1, true) || !compiler_pattern(c, alt, pc)) {
6693 ✗ goto error;
6694 }
6695 // Success!
6696 ✗ Py_ssize_t nstores = PyList_GET_SIZE(pc->stores);
6697 ✗ if (!i) {
6698 // This is the first alternative, so save its stores as a "control"
6699 // for the others (they can't bind a different set of names, and
6700 // might need to be reordered):
6701 assert(control == NULL);
6702 ✗ control = pc->stores;
6703 ✗ Py_INCREF(control);
6704 }
6705 ✗ else if (nstores != PyList_GET_SIZE(control)) {
6706 ✗ goto diff;
6707 }
6708 ✗ else if (nstores) {
6709 // There were captures. Check to see if we differ from control:
6710 ✗ Py_ssize_t icontrol = nstores;
6711 ✗ while (icontrol--) {
6712 ✗ PyObject *name = PyList_GET_ITEM(control, icontrol);
6713 ✗ Py_ssize_t istores = PySequence_Index(pc->stores, name);
6714 ✗ if (istores < 0) {
6715 ✗ PyErr_Clear();
6716 ✗ goto diff;
6717 }
6718 ✗ if (icontrol != istores) {
6719 // Reorder the names on the stack to match the order of the
6720 // names in control. There's probably a better way of doing
6721 // this; the current solution is potentially very
6722 // inefficient when each alternative subpattern binds lots
6723 // of names in different orders. It's fine for reasonable
6724 // cases, though, and the peephole optimizer will ensure
6725 // that the final code is as efficient as possible.
6726 assert(istores < icontrol);
6727 ✗ Py_ssize_t rotations = istores + 1;
6728 // Perform the same rotation on pc->stores:
6729 ✗ PyObject *rotated = PyList_GetSlice(pc->stores, 0,
6730 rotations);
6731 ✗ if (rotated == NULL ||
6732 ✗ PyList_SetSlice(pc->stores, 0, rotations, NULL) ||
6733 ✗ PyList_SetSlice(pc->stores, icontrol - istores,
6734 icontrol - istores, rotated))
6735 {
6736 ✗ Py_XDECREF(rotated);
6737 ✗ goto error;
6738 }
6739 ✗ Py_DECREF(rotated);
6740 // That just did:
6741 // rotated = pc_stores[:rotations]
6742 // del pc_stores[:rotations]
6743 // pc_stores[icontrol-istores:icontrol-istores] = rotated
6744 // Do the same thing to the stack, using several
6745 // rotations:
6746 ✗ while (rotations--) {
6747 ✗ if (!pattern_helper_rotate(c, icontrol + 1)){
6748 ✗ goto error;
6749 }
6750 }
6751 }
6752 }
6753 }
6754 assert(control);
6755 ✗ if (!compiler_addop_j(c, JUMP, end, true) ||
6756 ✗ !emit_and_reset_fail_pop(c, pc))
6757 {
6758 ✗ goto error;
6759 }
6760 }
6761 ✗ Py_DECREF(pc->stores);
6762 ✗ *pc = old_pc;
6763 ✗ Py_INCREF(pc->stores);
6764 // Need to NULL this for the PyObject_Free call in the error block.
6765 ✗ old_pc.fail_pop = NULL;
6766 // No match. Pop the remaining copy of the subject and fail:
6767 ✗ if (!compiler_addop(c, POP_TOP, true) || !jump_to_fail_pop(c, pc, JUMP)) {
6768 ✗ goto error;
6769 }
6770 ✗ compiler_use_next_block(c, end);
6771 ✗ Py_ssize_t nstores = PyList_GET_SIZE(control);
6772 // There's a bunch of stuff on the stack between where the new stores
6773 // are and where they need to be:
6774 // - The other stores.
6775 // - A copy of the subject.
6776 // - Anything else that may be on top of the stack.
6777 // - Any previous stores we've already stashed away on the stack.
6778 ✗ Py_ssize_t nrots = nstores + 1 + pc->on_top + PyList_GET_SIZE(pc->stores);
6779 ✗ for (Py_ssize_t i = 0; i < nstores; i++) {
6780 // Rotate this capture to its proper place on the stack:
6781 ✗ if (!pattern_helper_rotate(c, nrots)) {
6782 ✗ goto error;
6783 }
6784 // Update the list of previous stores with this new name, checking for
6785 // duplicates:
6786 ✗ PyObject *name = PyList_GET_ITEM(control, i);
6787 ✗ int dupe = PySequence_Contains(pc->stores, name);
6788 ✗ if (dupe < 0) {
6789 ✗ goto error;
6790 }
6791 ✗ if (dupe) {
6792 ✗ compiler_error_duplicate_store(c, name);
6793 ✗ goto error;
6794 }
6795 ✗ if (PyList_Append(pc->stores, name)) {
6796 ✗ goto error;
6797 }
6798 }
6799 ✗ Py_DECREF(old_pc.stores);
6800 ✗ Py_DECREF(control);
6801 // NOTE: Returning macros are safe again.
6802 // Pop the copy of the subject:
6803 ✗ ADDOP(c, POP_TOP);
6804 ✗ return 1;
6805 ✗ diff:
6806 ✗ compiler_error(c, "alternative patterns bind different names");
6807 ✗ error:
6808 ✗ PyObject_Free(old_pc.fail_pop);
6809 ✗ Py_DECREF(old_pc.stores);
6810 ✗ Py_XDECREF(control);
6811 ✗ return 0;
6812 }
6813
6814
6815 static int
6816 ✗ compiler_pattern_sequence(struct compiler *c, pattern_ty p, pattern_context *pc)
6817 {
6818 assert(p->kind == MatchSequence_kind);
6819 ✗ asdl_pattern_seq *patterns = p->v.MatchSequence.patterns;
6820 ✗ Py_ssize_t size = asdl_seq_LEN(patterns);
6821 ✗ Py_ssize_t star = -1;
6822 ✗ int only_wildcard = 1;
6823 ✗ int star_wildcard = 0;
6824 // Find a starred name, if it exists. There may be at most one:
6825 ✗ for (Py_ssize_t i = 0; i < size; i++) {
6826 ✗ pattern_ty pattern = asdl_seq_GET(patterns, i);
6827 ✗ if (pattern->kind == MatchStar_kind) {
6828 ✗ if (star >= 0) {
6829 ✗ const char *e = "multiple starred names in sequence pattern";
6830 ✗ return compiler_error(c, e);
6831 }
6832 ✗ star_wildcard = WILDCARD_STAR_CHECK(pattern);
6833 ✗ only_wildcard &= star_wildcard;
6834 ✗ star = i;
6835 ✗ continue;
6836 }
6837 ✗ only_wildcard &= WILDCARD_CHECK(pattern);
6838 }
6839 // We need to keep the subject on top during the sequence and length checks:
6840 ✗ pc->on_top++;
6841 ✗ ADDOP(c, MATCH_SEQUENCE);
6842 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6843 ✗ if (star < 0) {
6844 // No star: len(subject) == size
6845 ✗ ADDOP(c, GET_LEN);
6846 ✗ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size));
6847 ✗ ADDOP_COMPARE(c, Eq);
6848 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6849 }
6850 ✗ else if (size > 1) {
6851 // Star: len(subject) >= size - 1
6852 ✗ ADDOP(c, GET_LEN);
6853 ✗ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size - 1));
6854 ✗ ADDOP_COMPARE(c, GtE);
6855 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6856 }
6857 // Whatever comes next should consume the subject:
6858 ✗ pc->on_top--;
6859 ✗ if (only_wildcard) {
6860 // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
6861 ✗ ADDOP(c, POP_TOP);
6862 }
6863 ✗ else if (star_wildcard) {
6864 ✗ RETURN_IF_FALSE(pattern_helper_sequence_subscr(c, patterns, star, pc));
6865 }
6866 else {
6867 ✗ RETURN_IF_FALSE(pattern_helper_sequence_unpack(c, patterns, star, pc));
6868 }
6869 ✗ return 1;
6870 }
6871
6872 static int
6873 ✗ compiler_pattern_value(struct compiler *c, pattern_ty p, pattern_context *pc)
6874 {
6875 assert(p->kind == MatchValue_kind);
6876 ✗ expr_ty value = p->v.MatchValue.value;
6877 ✗ if (!MATCH_VALUE_EXPR(value)) {
6878 ✗ const char *e = "patterns may only match literals and attribute lookups";
6879 ✗ return compiler_error(c, e);
6880 }
6881 ✗ VISIT(c, expr, value);
6882 ✗ ADDOP_COMPARE(c, Eq);
6883 ✗ RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6884 ✗ return 1;
6885 }
6886
6887 static int
6888 1 compiler_pattern_singleton(struct compiler *c, pattern_ty p, pattern_context *pc)
6889 {
6890 assert(p->kind == MatchSingleton_kind);
6891
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 ADDOP_LOAD_CONST(c, p->v.MatchSingleton.value);
6892
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 ADDOP_COMPARE(c, Is);
6893
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 RETURN_IF_FALSE(jump_to_fail_pop(c, pc, POP_JUMP_IF_FALSE));
6894 1 return 1;
6895 }
6896
6897 static int
6898 8 compiler_pattern(struct compiler *c, pattern_ty p, pattern_context *pc)
6899 {
6900 8 SET_LOC(c, p);
6901
3/9
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
 8 switch (p->kind) {
6902 ✗ case MatchValue_kind:
6903 ✗ return compiler_pattern_value(c, p, pc);
6904 1 case MatchSingleton_kind:
6905 1 return compiler_pattern_singleton(c, p, pc);
6906 ✗ case MatchSequence_kind:
6907 ✗ return compiler_pattern_sequence(c, p, pc);
6908 ✗ case MatchMapping_kind:
6909 ✗ return compiler_pattern_mapping(c, p, pc);
6910 4 case MatchClass_kind:
6911 4 return compiler_pattern_class(c, p, pc);
6912 ✗ case MatchStar_kind:
6913 ✗ return compiler_pattern_star(c, p, pc);
6914 3 case MatchAs_kind:
6915 3 return compiler_pattern_as(c, p, pc);
6916 ✗ case MatchOr_kind:
6917 ✗ return compiler_pattern_or(c, p, pc);
6918 }
6919 // AST validator shouldn't let this happen, but if it does,
6920 // just fail, don't crash out of the interpreter
6921 ✗ const char *e = "invalid match pattern node in AST (kind=%d)";
6922 ✗ return compiler_error(c, e, p->kind);
6923 }
6924
6925 static int
6926 3 compiler_match_inner(struct compiler *c, stmt_ty s, pattern_context *pc)
6927 {
6928
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 VISIT(c, expr, s->v.Match.subject);
6929 basicblock *end;
6930
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 RETURN_IF_FALSE(end = compiler_new_block(c));
6931
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 Py_ssize_t cases = asdl_seq_LEN(s->v.Match.cases);
6932 assert(cases > 0);
6933 3 match_case_ty m = asdl_seq_GET(s->v.Match.cases, cases - 1);
6934
4/6
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 3 int has_default = WILDCARD_CHECK(m->pattern) && 1 < cases;
6935
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
 9 for (Py_ssize_t i = 0; i < cases - has_default; i++) {
6936 6 m = asdl_seq_GET(s->v.Match.cases, i);
6937 6 SET_LOC(c, m->pattern);
6938 // Only copy the subject if we're *not* on the last case:
6939
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
 6 if (i != cases - has_default - 1) {
6940
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP_I(c, COPY, 1);
6941 }
6942
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 RETURN_IF_FALSE(pc->stores = PyList_New(0));
6943 // Irrefutable cases must be either guarded, last, or both:
6944
4/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 3 times.
 6 pc->allow_irrefutable = m->guard != NULL || i == cases - 1;
6945 6 pc->fail_pop = NULL;
6946 6 pc->fail_pop_size = 0;
6947 6 pc->on_top = 0;
6948 // NOTE: Can't use returning macros here (they'll leak pc->stores)!
6949
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (!compiler_pattern(c, m->pattern, pc)) {
6950 ✗ Py_DECREF(pc->stores);
6951 ✗ return 0;
6952 }
6953 assert(!pc->on_top);
6954 // It's a match! Store all of the captured names (they're on the stack).
6955 6 Py_ssize_t nstores = PyList_GET_SIZE(pc->stores);
6956
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6 times.
 9 for (Py_ssize_t n = 0; n < nstores; n++) {
6957 3 PyObject *name = PyList_GET_ITEM(pc->stores, n);
6958
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (!compiler_nameop(c, name, Store)) {
6959 ✗ Py_DECREF(pc->stores);
6960 ✗ return 0;
6961 }
6962 }
6963 6 Py_DECREF(pc->stores);
6964 // NOTE: Returning macros are safe again.
6965
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
 6 if (m->guard) {
6966
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 RETURN_IF_FALSE(ensure_fail_pop(c, pc, 0));
6967
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 RETURN_IF_FALSE(compiler_jump_if(c, m->guard, pc->fail_pop[0], 0));
6968 }
6969 // Success! Pop the subject off, we're done with it:
6970
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
 6 if (i != cases - has_default - 1) {
6971
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 ADDOP(c, POP_TOP);
6972 }
6973
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 17 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 11 times.
✓ Branch 6 taken 6 times.
 17 VISIT_SEQ(c, stmt, m->body);
6974
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 ADDOP_JUMP(c, JUMP, end);
6975 // If the pattern fails to match, we want the line number of the
6976 // cleanup to be associated with the failed pattern, not the last line
6977 // of the body
6978 6 SET_LOC(c, m->pattern);
6979
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 RETURN_IF_FALSE(emit_and_reset_fail_pop(c, pc));
6980 }
6981
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
 3 if (has_default) {
6982 // A trailing "case _" is common, and lets us save a bit of redundant
6983 // pushing and popping in the loop above:
6984 1 m = asdl_seq_GET(s->v.Match.cases, cases - 1);
6985 1 SET_LOC(c, m->pattern);
6986
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (cases == 1) {
6987 // No matches. Done with the subject:
6988 ✗ ADDOP(c, POP_TOP);
6989 }
6990 else {
6991 // Show line coverage for default case (it doesn't create bytecode)
6992
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 ADDOP(c, NOP);
6993 }
6994
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (m->guard) {
6995 ✗ RETURN_IF_FALSE(compiler_jump_if(c, m->guard, end, 0));
6996 }
6997
4/6
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 1 times.
 2 VISIT_SEQ(c, stmt, m->body);
6998 }
6999 3 compiler_use_next_block(c, end);
7000 3 return 1;
7001 }
7002
7003 static int
7004 3 compiler_match(struct compiler *c, stmt_ty s)
7005 {
7006 pattern_context pc;
7007 3 pc.fail_pop = NULL;
7008 3 int result = compiler_match_inner(c, s, &pc);
7009 3 PyObject_Free(pc.fail_pop);
7010 3 return result;
7011 }
7012
7013 #undef WILDCARD_CHECK
7014 #undef WILDCARD_STAR_CHECK
7015
7016
7017 /* End of the compiler section, beginning of the assembler section */
7018
7019
7020 struct assembler {
7021 PyObject *a_bytecode; /* bytes containing bytecode */
7022 int a_offset; /* offset into bytecode */
7023 PyObject *a_except_table; /* bytes containing exception table */
7024 int a_except_table_off; /* offset into exception table */
7025 /* Location Info */
7026 int a_lineno; /* lineno of last emitted instruction */
7027 PyObject* a_linetable; /* bytes containing location info */
7028 int a_location_off; /* offset of last written location info frame */
7029 };
7030
7031 static basicblock**
7032 1991532 make_cfg_traversal_stack(basicblock *entryblock) {
7033 1991532 int nblocks = 0;
7034
2/2
✓ Branch 0 taken 6978899 times.
✓ Branch 1 taken 1991532 times.
 8970431 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7035 6978899 b->b_visited = 0;
7036 6978899 nblocks++;
7037 }
7038 1991532 basicblock **stack = (basicblock **)PyMem_Malloc(sizeof(basicblock *) * nblocks);
7039
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1991532 times.
 1991532 if (!stack) {
7040 ✗ PyErr_NoMemory();
7041 }
7042 1991532 return stack;
7043 }
7044
7045 Py_LOCAL_INLINE(void)
7046 1432499 stackdepth_push(basicblock ***sp, basicblock *b, int depth)
7047 {
7048 assert(b->b_startdepth < 0 || b->b_startdepth == depth);
7049
3/4
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 169715 times.
✓ Branch 2 taken 1262784 times.
✗ Branch 3 not taken.
 1432499 if (b->b_startdepth < depth && b->b_startdepth < 100) {
7050 assert(b->b_startdepth < 0);
7051 1262784 b->b_startdepth = depth;
7052 1262784 *(*sp)++ = b;
7053 }
7054 1432499 }
7055
7056 /* Find the flow path that needs the largest stack. We assume that
7057 * cycles in the flow graph have no net effect on the stack depth.
7058 */
7059 static int
7060 448800 stackdepth(basicblock *entryblock, int code_flags)
7061 {
7062
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7063 1262784 b->b_startdepth = INT_MIN;
7064 }
7065 448800 basicblock **stack = make_cfg_traversal_stack(entryblock);
7066
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!stack) {
7067 ✗ return -1;
7068 }
7069
7070 448800 int maxdepth = 0;
7071 448800 basicblock **sp = stack;
7072
2/2
✓ Branch 0 taken 9384 times.
✓ Branch 1 taken 439416 times.
 448800 if (code_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {
7073 9384 stackdepth_push(&sp, entryblock, 1);
7074 } else {
7075 439416 stackdepth_push(&sp, entryblock, 0);
7076 }
7077
7078
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 while (sp != stack) {
7079 1262784 basicblock *b = *--sp;
7080 1262784 int depth = b->b_startdepth;
7081 assert(depth >= 0);
7082 1262784 basicblock *next = b->b_next;
7083
2/2
✓ Branch 0 taken 14562721 times.
✓ Branch 1 taken 513193 times.
 15075914 for (int i = 0; i < b->b_iused; i++) {
7084 14562721 struct instr *instr = &b->b_instr[i];
7085 14562721 int effect = stack_effect(instr->i_opcode, instr->i_oparg, 0);
7086
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14562721 times.
 14562721 if (effect == PY_INVALID_STACK_EFFECT) {
7087 ✗ PyErr_Format(PyExc_SystemError,
7088 "compiler stack_effect(opcode=%d, arg=%i) failed",
7089 instr->i_opcode, instr->i_oparg);
7090 ✗ return -1;
7091 }
7092 14562721 int new_depth = depth + effect;
7093
2/2
✓ Branch 0 taken 1786487 times.
✓ Branch 1 taken 12776234 times.
 14562721 if (new_depth > maxdepth) {
7094 1786487 maxdepth = new_depth;
7095 }
7096 assert(depth >= 0); /* invalid code or bug in stackdepth() */
7097
4/4
✓ Branch 1 taken 14129690 times.
✓ Branch 2 taken 433031 times.
✓ Branch 4 taken 37475 times.
✓ Branch 5 taken 14092215 times.
 14562721 if (is_jump(instr) || is_block_push(instr)) {
7098 470506 effect = stack_effect(instr->i_opcode, instr->i_oparg, 1);
7099 assert(effect != PY_INVALID_STACK_EFFECT);
7100 470506 int target_depth = depth + effect;
7101
2/2
✓ Branch 0 taken 5229 times.
✓ Branch 1 taken 465277 times.
 470506 if (target_depth > maxdepth) {
7102 5229 maxdepth = target_depth;
7103 }
7104 assert(target_depth >= 0); /* invalid code or bug in stackdepth() */
7105 470506 stackdepth_push(&sp, instr->i_target, target_depth);
7106 }
7107 14562721 depth = new_depth;
7108 assert(!IS_ASSEMBLER_OPCODE(instr->i_opcode));
7109
7/10
✓ Branch 0 taken 14466949 times.
✓ Branch 1 taken 95772 times.
✓ Branch 2 taken 14465291 times.
✓ Branch 3 taken 1658 times.
✓ Branch 4 taken 14465291 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 14465291 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 14465291 times.
✗ Branch 9 not taken.
 14562721 if (IS_UNCONDITIONAL_JUMP_OPCODE(instr->i_opcode) ||
7110
6/6
✓ Branch 0 taken 13950610 times.
✓ Branch 1 taken 514681 times.
✓ Branch 2 taken 13850593 times.
✓ Branch 3 taken 100017 times.
✓ Branch 4 taken 37463 times.
✓ Branch 5 taken 13813130 times.
 14465291 IS_SCOPE_EXIT_OPCODE(instr->i_opcode))
7111 {
7112 /* remaining code is dead */
7113 749591 next = NULL;
7114 749591 break;
7115 }
7116
2/2
✓ Branch 0 taken 11907 times.
✓ Branch 1 taken 13801223 times.
 13813130 if (instr->i_opcode == YIELD_VALUE) {
7117 11907 instr->i_oparg = depth;
7118 }
7119 }
7120
2/2
✓ Branch 0 taken 513193 times.
✓ Branch 1 taken 749591 times.
 1262784 if (next != NULL) {
7121 assert(BB_HAS_FALLTHROUGH(b));
7122 513193 stackdepth_push(&sp, next, depth);
7123 }
7124 }
7125 448800 PyMem_Free(stack);
7126 448800 return maxdepth;
7127 }
7128
7129 static int
7130 448800 assemble_init(struct assembler *a, int firstlineno)
7131 {
7132 448800 memset(a, 0, sizeof(struct assembler));
7133 448800 a->a_lineno = firstlineno;
7134 448800 a->a_linetable = NULL;
7135 448800 a->a_location_off = 0;
7136 448800 a->a_except_table = NULL;
7137 448800 a->a_bytecode = PyBytes_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
7138
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (a->a_bytecode == NULL) {
7139 ✗ goto error;
7140 }
7141 448800 a->a_linetable = PyBytes_FromStringAndSize(NULL, DEFAULT_CNOTAB_SIZE);
7142
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (a->a_linetable == NULL) {
7143 ✗ goto error;
7144 }
7145 448800 a->a_except_table = PyBytes_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
7146
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (a->a_except_table == NULL) {
7147 ✗ goto error;
7148 }
7149 448800 return 1;
7150 ✗ error:
7151 ✗ Py_XDECREF(a->a_bytecode);
7152 ✗ Py_XDECREF(a->a_linetable);
7153 ✗ Py_XDECREF(a->a_except_table);
7154 ✗ return 0;
7155 }
7156
7157 static void
7158 448800 assemble_free(struct assembler *a)
7159 {
7160 448800 Py_XDECREF(a->a_bytecode);
7161 448800 Py_XDECREF(a->a_linetable);
7162 448800 Py_XDECREF(a->a_except_table);
7163 448800 }
7164
7165 static int
7166 1412234 blocksize(basicblock *b)
7167 {
7168 int i;
7169 1412234 int size = 0;
7170
7171
2/2
✓ Branch 0 taken 17389967 times.
✓ Branch 1 taken 1412234 times.
 18802201 for (i = 0; i < b->b_iused; i++) {
7172 17389967 size += instr_size(&b->b_instr[i]);
7173 }
7174 1412234 return size;
7175 }
7176
7177 static basicblock *
7178 37475 push_except_block(ExceptStack *stack, struct instr *setup) {
7179 assert(is_block_push(setup));
7180 37475 int opcode = setup->i_opcode;
7181 37475 basicblock * target = setup->i_target;
7182
4/4
✓ Branch 0 taken 33114 times.
✓ Branch 1 taken 4361 times.
✓ Branch 2 taken 19751 times.
✓ Branch 3 taken 13363 times.
 37475 if (opcode == SETUP_WITH || opcode == SETUP_CLEANUP) {
7183 24112 target->b_preserve_lasti = 1;
7184 }
7185 37475 stack->handlers[++stack->depth] = target;
7186 37475 return target;
7187 }
7188
7189 static basicblock *
7190 33655 pop_except_block(ExceptStack *stack) {
7191 assert(stack->depth > 0);
7192 33655 return stack->handlers[--stack->depth];
7193 }
7194
7195 static basicblock *
7196 1262784 except_stack_top(ExceptStack *stack) {
7197 1262784 return stack->handlers[stack->depth];
7198 }
7199
7200 static ExceptStack *
7201 448800 make_except_stack(void) {
7202 448800 ExceptStack *new = PyMem_Malloc(sizeof(ExceptStack));
7203
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (new == NULL) {
7204 ✗ PyErr_NoMemory();
7205 ✗ return NULL;
7206 }
7207 448800 new->depth = 0;
7208 448800 new->handlers[0] = NULL;
7209 448800 return new;
7210 }
7211
7212 static ExceptStack *
7213 333470 copy_except_stack(ExceptStack *stack) {
7214 333470 ExceptStack *copy = PyMem_Malloc(sizeof(ExceptStack));
7215
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 333470 times.
 333470 if (copy == NULL) {
7216 ✗ PyErr_NoMemory();
7217 ✗ return NULL;
7218 }
7219 333470 memcpy(copy, stack, sizeof(ExceptStack));
7220 333470 return copy;
7221 }
7222
7223 static int
7224 448800 label_exception_targets(basicblock *entryblock) {
7225 448800 basicblock **todo_stack = make_cfg_traversal_stack(entryblock);
7226
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (todo_stack == NULL) {
7227 ✗ return -1;
7228 }
7229 448800 ExceptStack *except_stack = make_except_stack();
7230
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (except_stack == NULL) {
7231 ✗ PyMem_Free(todo_stack);
7232 ✗ PyErr_NoMemory();
7233 ✗ return -1;
7234 }
7235 448800 except_stack->depth = 0;
7236 448800 todo_stack[0] = entryblock;
7237 448800 entryblock->b_visited = 1;
7238 448800 entryblock->b_exceptstack = except_stack;
7239 448800 basicblock **todo = &todo_stack[1];
7240 448800 basicblock *handler = NULL;
7241
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 while (todo > todo_stack) {
7242 1262784 todo--;
7243 1262784 basicblock *b = todo[0];
7244 assert(b->b_visited == 1);
7245 1262784 except_stack = b->b_exceptstack;
7246 assert(except_stack != NULL);
7247 1262784 b->b_exceptstack = NULL;
7248 1262784 handler = except_stack_top(except_stack);
7249
2/2
✓ Branch 0 taken 14562721 times.
✓ Branch 1 taken 1262784 times.
 15825505 for (int i = 0; i < b->b_iused; i++) {
7250 14562721 struct instr *instr = &b->b_instr[i];
7251
2/2
✓ Branch 1 taken 37475 times.
✓ Branch 2 taken 14525246 times.
 14562721 if (is_block_push(instr)) {
7252
1/2
✓ Branch 0 taken 37475 times.
✗ Branch 1 not taken.
 37475 if (!instr->i_target->b_visited) {
7253 37475 ExceptStack *copy = copy_except_stack(except_stack);
7254
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37475 times.
 37475 if (copy == NULL) {
7255 ✗ goto error;
7256 }
7257 37475 instr->i_target->b_exceptstack = copy;
7258 37475 todo[0] = instr->i_target;
7259 37475 instr->i_target->b_visited = 1;
7260 37475 todo++;
7261 }
7262 37475 handler = push_except_block(except_stack, instr);
7263 }
7264
2/2
✓ Branch 0 taken 33655 times.
✓ Branch 1 taken 14491591 times.
 14525246 else if (instr->i_opcode == POP_BLOCK) {
7265 33655 handler = pop_except_block(except_stack);
7266 }
7267
2/2
✓ Branch 1 taken 433031 times.
✓ Branch 2 taken 14058560 times.
 14491591 else if (is_jump(instr)) {
7268 433031 instr->i_except = handler;
7269 assert(i == b->b_iused -1);
7270
2/2
✓ Branch 0 taken 321960 times.
✓ Branch 1 taken 111071 times.
 433031 if (!instr->i_target->b_visited) {
7271
2/2
✓ Branch 1 taken 295995 times.
✓ Branch 2 taken 25965 times.
 321960 if (BB_HAS_FALLTHROUGH(b)) {
7272 295995 ExceptStack *copy = copy_except_stack(except_stack);
7273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 295995 times.
 295995 if (copy == NULL) {
7274 ✗ goto error;
7275 }
7276 295995 instr->i_target->b_exceptstack = copy;
7277 }
7278 else {
7279 25965 instr->i_target->b_exceptstack = except_stack;
7280 25965 except_stack = NULL;
7281 }
7282 321960 todo[0] = instr->i_target;
7283 321960 instr->i_target->b_visited = 1;
7284 321960 todo++;
7285 }
7286 }
7287 else {
7288 14058560 instr->i_except = handler;
7289 }
7290 }
7291
4/4
✓ Branch 1 taken 513193 times.
✓ Branch 2 taken 749591 times.
✓ Branch 3 taken 454549 times.
✓ Branch 4 taken 58644 times.
 1262784 if (BB_HAS_FALLTHROUGH(b) && !b->b_next->b_visited) {
7292 assert(except_stack != NULL);
7293 454549 b->b_next->b_exceptstack = except_stack;
7294 454549 todo[0] = b->b_next;
7295 454549 b->b_next->b_visited = 1;
7296 454549 todo++;
7297 }
7298
2/2
✓ Branch 0 taken 782270 times.
✓ Branch 1 taken 25965 times.
 808235 else if (except_stack != NULL) {
7299 782270 PyMem_Free(except_stack);
7300 }
7301 }
7302 #ifdef Py_DEBUG
7303 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7304 assert(b->b_exceptstack == NULL);
7305 }
7306 #endif
7307 448800 PyMem_Free(todo_stack);
7308 448800 return 0;
7309 ✗ error:
7310 ✗ PyMem_Free(todo_stack);
7311 ✗ PyMem_Free(except_stack);
7312 ✗ return -1;
7313 }
7314
7315 static int
7316 98166 mark_warm(basicblock *entryblock) {
7317 98166 basicblock **stack = make_cfg_traversal_stack(entryblock);
7318
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98166 times.
 98166 if (stack == NULL) {
7319 ✗ return -1;
7320 }
7321 98166 basicblock **sp = stack;
7322
7323 98166 *sp++ = entryblock;
7324 98166 entryblock->b_visited = 1;
7325
2/2
✓ Branch 0 taken 823007 times.
✓ Branch 1 taken 98166 times.
 921173 while (sp > stack) {
7326 823007 basicblock *b = *(--sp);
7327 assert(!b->b_except_predecessors);
7328 823007 b->b_warm = 1;
7329 823007 basicblock *next = b->b_next;
7330
6/6
✓ Branch 0 taken 730882 times.
✓ Branch 1 taken 92125 times.
✓ Branch 3 taken 480286 times.
✓ Branch 4 taken 250596 times.
✓ Branch 5 taken 436793 times.
✓ Branch 6 taken 43493 times.
 823007 if (next && BB_HAS_FALLTHROUGH(b) && !next->b_visited) {
7331 436793 *sp++ = next;
7332 436793 next->b_visited = 1;
7333 }
7334
2/2
✓ Branch 0 taken 8640465 times.
✓ Branch 1 taken 823007 times.
 9463472 for (int i=0; i < b->b_iused; i++) {
7335 8640465 struct instr *instr = &b->b_instr[i];
7336
4/4
✓ Branch 1 taken 405350 times.
✓ Branch 2 taken 8235115 times.
✓ Branch 3 taken 288048 times.
✓ Branch 4 taken 117302 times.
 8640465 if (is_jump(instr) && !instr->i_target->b_visited) {
7337 288048 *sp++ = instr->i_target;
7338 288048 instr->i_target->b_visited = 1;
7339 }
7340 }
7341 }
7342 98166 PyMem_Free(stack);
7343 98166 return 0;
7344 }
7345
7346 static int
7347 98166 mark_cold(basicblock *entryblock) {
7348
2/2
✓ Branch 0 taken 912150 times.
✓ Branch 1 taken 98166 times.
 1010316 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7349 assert(!b->b_cold && !b->b_warm);
7350 }
7351
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 98166 times.
 98166 if (mark_warm(entryblock) < 0) {
7352 ✗ return -1;
7353 }
7354
7355 98166 basicblock **stack = make_cfg_traversal_stack(entryblock);
7356
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 98166 times.
 98166 if (stack == NULL) {
7357 ✗ return -1;
7358 }
7359
7360 98166 basicblock **sp = stack;
7361
2/2
✓ Branch 0 taken 912150 times.
✓ Branch 1 taken 98166 times.
 1010316 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7362
2/2
✓ Branch 0 taken 37475 times.
✓ Branch 1 taken 874675 times.
 912150 if (b->b_except_predecessors) {
7363 assert(b->b_except_predecessors == b->b_predecessors);
7364 assert(!b->b_warm);
7365 37475 *sp++ = b;
7366 37475 b->b_visited = 1;
7367 }
7368 }
7369
7370
2/2
✓ Branch 0 taken 89143 times.
✓ Branch 1 taken 98166 times.
 187309 while (sp > stack) {
7371 89143 basicblock *b = *(--sp);
7372 89143 b->b_cold = 1;
7373 89143 basicblock *next = b->b_next;
7374
4/4
✓ Branch 0 taken 83102 times.
✓ Branch 1 taken 6041 times.
✓ Branch 3 taken 32907 times.
✓ Branch 4 taken 50195 times.
 89143 if (next && BB_HAS_FALLTHROUGH(b)) {
7375
4/4
✓ Branch 0 taken 32885 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 32181 times.
✓ Branch 3 taken 704 times.
 32907 if (!next->b_warm && !next->b_visited) {
7376 32181 *sp++ = next;
7377 32181 next->b_visited = 1;
7378 }
7379 }
7380
2/2
✓ Branch 0 taken 340086 times.
✓ Branch 1 taken 89143 times.
 429229 for (int i = 0; i < b->b_iused; i++) {
7381 340086 struct instr *instr = &b->b_instr[i];
7382
2/2
✓ Branch 1 taken 27681 times.
✓ Branch 2 taken 312405 times.
 340086 if (is_jump(instr)) {
7383 assert(i == b->b_iused-1);
7384 27681 basicblock *target = b->b_instr[i].i_target;
7385
4/4
✓ Branch 0 taken 20596 times.
✓ Branch 1 taken 7085 times.
✓ Branch 2 taken 19487 times.
✓ Branch 3 taken 1109 times.
 27681 if (!target->b_warm && !target->b_visited) {
7386 19487 *sp++ = target;
7387 19487 target->b_visited = 1;
7388 }
7389 }
7390 }
7391 }
7392 98166 PyMem_Free(stack);
7393 98166 return 0;
7394 }
7395
7396 static int
7397 448800 push_cold_blocks_to_end(basicblock *entryblock, int code_flags) {
7398
2/2
✓ Branch 0 taken 350634 times.
✓ Branch 1 taken 98166 times.
 448800 if (entryblock->b_next == NULL) {
7399 /* single basicblock, no need to reorder */
7400 350634 return 0;
7401 }
7402
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 98166 times.
 98166 if (mark_cold(entryblock) < 0) {
7403 ✗ return -1;
7404 }
7405
7406 /* If we have a cold block with fallthrough to a warm block, add */
7407 /* an explicit jump instead of fallthrough */
7408
2/2
✓ Branch 0 taken 912172 times.
✓ Branch 1 taken 98166 times.
 1010338 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7409
7/8
✓ Branch 0 taken 89165 times.
✓ Branch 1 taken 823007 times.
✓ Branch 3 taken 32907 times.
✓ Branch 4 taken 56258 times.
✓ Branch 5 taken 32907 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 22 times.
✓ Branch 8 taken 32885 times.
 912172 if (b->b_cold && BB_HAS_FALLTHROUGH(b) && b->b_next && b->b_next->b_warm) {
7410 22 basicblock *explicit_jump = basicblock_new_b_list_successor(b);
7411
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
 22 if (explicit_jump == NULL) {
7412 ✗ return -1;
7413 }
7414 22 basicblock_addop(explicit_jump, JUMP, 0, b->b_next, &NO_LOCATION);
7415
7416 22 explicit_jump->b_cold = 1;
7417 22 explicit_jump->b_next = b->b_next;
7418 22 b->b_next = explicit_jump;
7419 }
7420 }
7421
7422 assert(!entryblock->b_cold); /* First block can't be cold */
7423 98166 basicblock *cold_blocks = NULL;
7424 98166 basicblock *cold_blocks_tail = NULL;
7425
7426 98166 basicblock *b = entryblock;
7427
2/2
✓ Branch 0 taken 108950 times.
✓ Branch 1 taken 6041 times.
 114991 while(b->b_next) {
7428 assert(!b->b_cold);
7429
4/4
✓ Branch 0 taken 741666 times.
✓ Branch 1 taken 92125 times.
✓ Branch 2 taken 724841 times.
✓ Branch 3 taken 16825 times.
 833791 while (b->b_next && !b->b_next->b_cold) {
7430 724841 b = b->b_next;
7431 }
7432
2/2
✓ Branch 0 taken 92125 times.
✓ Branch 1 taken 16825 times.
 108950 if (b->b_next == NULL) {
7433 /* no more cold blocks */
7434 92125 break;
7435 }
7436
7437 /* b->b_next is the beginning of a cold streak */
7438 assert(!b->b_cold && b->b_next->b_cold);
7439
7440 16825 basicblock *b_end = b->b_next;
7441
4/4
✓ Branch 0 taken 83124 times.
✓ Branch 1 taken 6041 times.
✓ Branch 2 taken 72340 times.
✓ Branch 3 taken 10784 times.
 89165 while (b_end->b_next && b_end->b_next->b_cold) {
7442 72340 b_end = b_end->b_next;
7443 }
7444
7445 /* b_end is the end of the cold streak */
7446 assert(b_end && b_end->b_cold);
7447 assert(b_end->b_next == NULL || !b_end->b_next->b_cold);
7448
7449
2/2
✓ Branch 0 taken 13042 times.
✓ Branch 1 taken 3783 times.
 16825 if (cold_blocks == NULL) {
7450 13042 cold_blocks = b->b_next;
7451 }
7452 else {
7453 3783 cold_blocks_tail->b_next = b->b_next;
7454 }
7455 16825 cold_blocks_tail = b_end;
7456 16825 b->b_next = b_end->b_next;
7457 16825 b_end->b_next = NULL;
7458 }
7459 assert(b != NULL && b->b_next == NULL);
7460 98166 b->b_next = cold_blocks;
7461 98166 return 0;
7462 }
7463
7464 static void
7465 448800 convert_exception_handlers_to_nops(basicblock *entryblock) {
7466
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7467
2/2
✓ Branch 0 taken 14562721 times.
✓ Branch 1 taken 1262784 times.
 15825505 for (int i = 0; i < b->b_iused; i++) {
7468 14562721 struct instr *instr = &b->b_instr[i];
7469
4/4
✓ Branch 1 taken 14525246 times.
✓ Branch 2 taken 37475 times.
✓ Branch 3 taken 33655 times.
✓ Branch 4 taken 14491591 times.
 14562721 if (is_block_push(instr) || instr->i_opcode == POP_BLOCK) {
7470 71130 instr->i_opcode = NOP;
7471 }
7472 }
7473 }
7474 448800 }
7475
7476 static inline void
7477 300475 write_except_byte(struct assembler *a, int byte) {
7478 300475 unsigned char *p = (unsigned char *) PyBytes_AS_STRING(a->a_except_table);
7479 300475 p[a->a_except_table_off++] = byte;
7480 300475 }
7481
7482 #define CONTINUATION_BIT 64
7483
7484 static void
7485 211984 assemble_emit_exception_table_item(struct assembler *a, int value, int msb)
7486 {
7487 assert ((msb | 128) == 128);
7488 assert(value >= 0 && value < (1 << 30));
7489
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 211984 times.
 211984 if (value >= 1 << 24) {
7490 ✗ write_except_byte(a, (value >> 24) | CONTINUATION_BIT | msb);
7491 ✗ msb = 0;
7492 }
7493
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 211984 times.
 211984 if (value >= 1 << 18) {
7494 ✗ write_except_byte(a, ((value >> 18)&0x3f) | CONTINUATION_BIT | msb);
7495 ✗ msb = 0;
7496 }
7497
2/2
✓ Branch 0 taken 329 times.
✓ Branch 1 taken 211655 times.
 211984 if (value >= 1 << 12) {
7498 329 write_except_byte(a, ((value >> 12)&0x3f) | CONTINUATION_BIT | msb);
7499 329 msb = 0;
7500 }
7501
2/2
✓ Branch 0 taken 88162 times.
✓ Branch 1 taken 123822 times.
 211984 if (value >= 1 << 6) {
7502 88162 write_except_byte(a, ((value >> 6)&0x3f) | CONTINUATION_BIT | msb);
7503 88162 msb = 0;
7504 }
7505 211984 write_except_byte(a, (value&0x3f) | msb);
7506 211984 }
7507
7508 /* See Objects/exception_handling_notes.txt for details of layout */
7509 #define MAX_SIZE_OF_ENTRY 20
7510
7511 static int
7512 52996 assemble_emit_exception_table_entry(struct assembler *a, int start, int end, basicblock *handler)
7513 {
7514 52996 Py_ssize_t len = PyBytes_GET_SIZE(a->a_except_table);
7515
2/2
✓ Branch 0 taken 20041 times.
✓ Branch 1 taken 32955 times.
 52996 if (a->a_except_table_off + MAX_SIZE_OF_ENTRY >= len) {
7516
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20041 times.
 20041 if (_PyBytes_Resize(&a->a_except_table, len * 2) < 0)
7517 ✗ return 0;
7518 }
7519 52996 int size = end-start;
7520 assert(end > start);
7521 52996 int target = handler->b_offset;
7522 52996 int depth = handler->b_startdepth - 1;
7523
2/2
✓ Branch 0 taken 37620 times.
✓ Branch 1 taken 15376 times.
 52996 if (handler->b_preserve_lasti) {
7524 37620 depth -= 1;
7525 }
7526 assert(depth >= 0);
7527 52996 int depth_lasti = (depth<<1) | handler->b_preserve_lasti;
7528 52996 assemble_emit_exception_table_item(a, start, (1<<7));
7529 52996 assemble_emit_exception_table_item(a, size, 0);
7530 52996 assemble_emit_exception_table_item(a, target, 0);
7531 52996 assemble_emit_exception_table_item(a, depth_lasti, 0);
7532 52996 return 1;
7533 }
7534
7535 static int
7536 448800 assemble_exception_table(struct assembler *a, basicblock *entryblock)
7537 {
7538 basicblock *b;
7539 448800 int ioffset = 0;
7540 448800 basicblock *handler = NULL;
7541 448800 int start = -1;
7542
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (b = entryblock; b != NULL; b = b->b_next) {
7543 1262806 ioffset = b->b_offset;
7544
2/2
✓ Branch 0 taken 14497150 times.
✓ Branch 1 taken 1262806 times.
 15759956 for (int i = 0; i < b->b_iused; i++) {
7545 14497150 struct instr *instr = &b->b_instr[i];
7546
2/2
✓ Branch 0 taken 94663 times.
✓ Branch 1 taken 14402487 times.
 14497150 if (instr->i_except != handler) {
7547
2/2
✓ Branch 0 taken 52996 times.
✓ Branch 1 taken 41667 times.
 94663 if (handler != NULL) {
7548
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 52996 times.
 52996 RETURN_IF_FALSE(assemble_emit_exception_table_entry(a, start, ioffset, handler));
7549 }
7550 94663 start = ioffset;
7551 94663 handler = instr->i_except;
7552 }
7553 14497150 ioffset += instr_size(instr);
7554 }
7555 }
7556
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (handler != NULL) {
7557 ✗ RETURN_IF_FALSE(assemble_emit_exception_table_entry(a, start, ioffset, handler));
7558 }
7559 448800 return 1;
7560 }
7561
7562 /* Code location emitting code. See locations.md for a description of the format. */
7563
7564 #define MSB 0x80
7565
7566 static void
7567 15111328 write_location_byte(struct assembler* a, int val)
7568 {
7569 15111328 PyBytes_AS_STRING(a->a_linetable)[a->a_location_off] = val&255;
7570 15111328 a->a_location_off++;
7571 15111328 }
7572
7573
7574 static uint8_t *
7575 33076852 location_pointer(struct assembler* a)
7576 {
7577 33076852 return (uint8_t *)PyBytes_AS_STRING(a->a_linetable) +
7578 33076852 a->a_location_off;
7579 }
7580
7581 static void
7582 15204649 write_location_first_byte(struct assembler* a, int code, int length)
7583 {
7584 15204649 a->a_location_off += write_location_entry_start(
7585 location_pointer(a), code, length);
7586 15204649 }
7587
7588 static void
7589 13389426 write_location_varint(struct assembler* a, unsigned int val)
7590 {
7591 13389426 uint8_t *ptr = location_pointer(a);
7592 13389426 a->a_location_off += write_varint(ptr, val);
7593 13389426 }
7594
7595
7596 static void
7597 4482777 write_location_signed_varint(struct assembler* a, int val)
7598 {
7599 4482777 uint8_t *ptr = location_pointer(a);
7600 4482777 a->a_location_off += write_signed_varint(ptr, val);
7601 4482777 }
7602
7603 static void
7604 5796020 write_location_info_short_form(struct assembler* a, int length, int column, int end_column)
7605 {
7606 assert(length > 0 && length <= 8);
7607 5796020 int column_low_bits = column & 7;
7608 5796020 int column_group = column >> 3;
7609 assert(column < 80);
7610 assert(end_column >= column);
7611 assert(end_column - column < 16);
7612 5796020 write_location_first_byte(a, PY_CODE_LOCATION_INFO_SHORT0 + column_group, length);
7613 5796020 write_location_byte(a, (column_low_bits << 4) | (end_column - column));
7614 5796020 }
7615
7616 static void
7617 4657654 write_location_info_oneline_form(struct assembler* a, int length, int line_delta, int column, int end_column)
7618 {
7619 assert(length > 0 && length <= 8);
7620 assert(line_delta >= 0 && line_delta < 3);
7621 assert(column < 128);
7622 assert(end_column < 128);
7623 4657654 write_location_first_byte(a, PY_CODE_LOCATION_INFO_ONE_LINE0 + line_delta, length);
7624 4657654 write_location_byte(a, column);
7625 4657654 write_location_byte(a, end_column);
7626 4657654 }
7627
7628 static void
7629 4463142 write_location_info_long_form(struct assembler* a, struct instr* i, int length)
7630 {
7631 assert(length > 0 && length <= 8);
7632 4463142 write_location_first_byte(a, PY_CODE_LOCATION_INFO_LONG, length);
7633 4463142 write_location_signed_varint(a, i->i_loc.lineno - a->a_lineno);
7634 assert(i->i_loc.end_lineno >= i->i_loc.lineno);
7635 4463142 write_location_varint(a, i->i_loc.end_lineno - i->i_loc.lineno);
7636 4463142 write_location_varint(a, i->i_loc.col_offset + 1);
7637 4463142 write_location_varint(a, i->i_loc.end_col_offset + 1);
7638 4463142 }
7639
7640 static void
7641 268198 write_location_info_none(struct assembler* a, int length)
7642 {
7643 268198 write_location_first_byte(a, PY_CODE_LOCATION_INFO_NONE, length);
7644 268198 }
7645
7646 static void
7647 19635 write_location_info_no_column(struct assembler* a, int length, int line_delta)
7648 {
7649 19635 write_location_first_byte(a, PY_CODE_LOCATION_INFO_NO_COLUMNS, length);
7650 19635 write_location_signed_varint(a, line_delta);
7651 19635 }
7652
7653 #define THEORETICAL_MAX_ENTRY_SIZE 25 /* 1 + 6 + 6 + 6 + 6 */
7654
7655 static int
7656 15204649 write_location_info_entry(struct assembler* a, struct instr* i, int isize)
7657 {
7658 15204649 Py_ssize_t len = PyBytes_GET_SIZE(a->a_linetable);
7659
2/2
✓ Branch 0 taken 713439 times.
✓ Branch 1 taken 14491210 times.
 15204649 if (a->a_location_off + THEORETICAL_MAX_ENTRY_SIZE >= len) {
7660 assert(len > THEORETICAL_MAX_ENTRY_SIZE);
7661
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 713439 times.
 713439 if (_PyBytes_Resize(&a->a_linetable, len*2) < 0) {
7662 ✗ return 0;
7663 }
7664 }
7665
2/2
✓ Branch 0 taken 268198 times.
✓ Branch 1 taken 14936451 times.
 15204649 if (i->i_loc.lineno < 0) {
7666 268198 write_location_info_none(a, isize);
7667 268198 return 1;
7668 }
7669 14936451 int line_delta = i->i_loc.lineno - a->a_lineno;
7670 14936451 int column = i->i_loc.col_offset;
7671 14936451 int end_column = i->i_loc.end_col_offset;
7672 assert(column >= -1);
7673 assert(end_column >= -1);
7674
3/4
✓ Branch 0 taken 14916816 times.
✓ Branch 1 taken 19635 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14916816 times.
 14936451 if (column < 0 || end_column < 0) {
7675
3/4
✓ Branch 0 taken 867 times.
✓ Branch 1 taken 18768 times.
✓ Branch 2 taken 867 times.
✗ Branch 3 not taken.
 19635 if (i->i_loc.end_lineno == i->i_loc.lineno || i->i_loc.end_lineno == -1) {
7676 19635 write_location_info_no_column(a, isize, line_delta);
7677 19635 a->a_lineno = i->i_loc.lineno;
7678 19635 return 1;
7679 }
7680 }
7681
2/2
✓ Branch 0 taken 13264935 times.
✓ Branch 1 taken 1651881 times.
 14916816 else if (i->i_loc.end_lineno == i->i_loc.lineno) {
7682
8/8
✓ Branch 0 taken 11848001 times.
✓ Branch 1 taken 1416934 times.
✓ Branch 2 taken 8970137 times.
✓ Branch 3 taken 2877864 times.
✓ Branch 4 taken 5796039 times.
✓ Branch 5 taken 3174098 times.
✓ Branch 6 taken 5796020 times.
✓ Branch 7 taken 19 times.
 13264935 if (line_delta == 0 && column < 80 && end_column - column < 16 && end_column >= column) {
7683 5796020 write_location_info_short_form(a, isize, column, end_column);
7684 5796020 return 1;
7685 }
7686
8/8
✓ Branch 0 taken 7430932 times.
✓ Branch 1 taken 37983 times.
✓ Branch 2 taken 7135152 times.
✓ Branch 3 taken 295780 times.
✓ Branch 4 taken 5173641 times.
✓ Branch 5 taken 1961511 times.
✓ Branch 6 taken 4657654 times.
✓ Branch 7 taken 515987 times.
 7468915 if (line_delta >= 0 && line_delta < 3 && column < 128 && end_column < 128) {
7687 4657654 write_location_info_oneline_form(a, isize, line_delta, column, end_column);
7688 4657654 a->a_lineno = i->i_loc.lineno;
7689 4657654 return 1;
7690 }
7691 }
7692 4463142 write_location_info_long_form(a, i, isize);
7693 4463142 a->a_lineno = i->i_loc.lineno;
7694 4463142 return 1;
7695 }
7696
7697 static int
7698 14497150 assemble_emit_location(struct assembler* a, struct instr* i)
7699 {
7700 14497150 int isize = instr_size(i);
7701
2/2
✓ Branch 0 taken 707499 times.
✓ Branch 1 taken 14497150 times.
 15204649 while (isize > 8) {
7702
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 707499 times.
 707499 if (!write_location_info_entry(a, i, 8)) {
7703 ✗ return 0;
7704 }
7705 707499 isize -= 8;
7706 }
7707 14497150 return write_location_info_entry(a, i, isize);
7708 }
7709
7710 /* assemble_emit()
7711 Extend the bytecode with a new instruction.
7712 Update lnotab if necessary.
7713 */
7714
7715 static int
7716 14497150 assemble_emit(struct assembler *a, struct instr *i)
7717 {
7718 14497150 Py_ssize_t len = PyBytes_GET_SIZE(a->a_bytecode);
7719 _Py_CODEUNIT *code;
7720
7721 14497150 int size = instr_size(i);
7722
2/2
✓ Branch 0 taken 177205 times.
✓ Branch 1 taken 14319945 times.
 14497150 if (a->a_offset + size >= len / (int)sizeof(_Py_CODEUNIT)) {
7723
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 177205 times.
 177205 if (len > PY_SSIZE_T_MAX / 2)
7724 ✗ return 0;
7725
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 177205 times.
 177205 if (_PyBytes_Resize(&a->a_bytecode, len * 2) < 0)
7726 ✗ return 0;
7727 }
7728 14497150 code = (_Py_CODEUNIT *)PyBytes_AS_STRING(a->a_bytecode) + a->a_offset;
7729 14497150 a->a_offset += size;
7730 14497150 write_instr(code, i, size);
7731 14497150 return 1;
7732 }
7733
7734 static void
7735 448800 normalize_jumps(basicblock *entryblock)
7736 {
7737
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7738 1262806 b->b_visited = 0;
7739 }
7740
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7741 1262806 b->b_visited = 1;
7742
2/2
✓ Branch 0 taken 368 times.
✓ Branch 1 taken 1262438 times.
 1262806 if (b->b_iused == 0) {
7743 368 continue;
7744 }
7745 1262438 struct instr *last = &b->b_instr[b->b_iused-1];
7746 assert(!IS_ASSEMBLER_OPCODE(last->i_opcode));
7747
2/2
✓ Branch 1 taken 423956 times.
✓ Branch 2 taken 838482 times.
 1262438 if (is_jump(last)) {
7748 423956 bool is_forward = last->i_target->b_visited == 0;
7749
8/8
✓ Branch 0 taken 86697 times.
✓ Branch 1 taken 1658 times.
✓ Branch 2 taken 8595 times.
✓ Branch 3 taken 11618 times.
✓ Branch 4 taken 144917 times.
✓ Branch 5 taken 105018 times.
✓ Branch 6 taken 13428 times.
✓ Branch 7 taken 52025 times.
 423956 switch(last->i_opcode) {
7750 86697 case JUMP:
7751
2/2
✓ Branch 0 taken 25692 times.
✓ Branch 1 taken 61005 times.
 86697 last->i_opcode = is_forward ? JUMP_FORWARD : JUMP_BACKWARD;
7752 86697 break;
7753 1658 case JUMP_NO_INTERRUPT:
7754 1658 last->i_opcode = is_forward ?
7755
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1658 times.
 1658 JUMP_FORWARD : JUMP_BACKWARD_NO_INTERRUPT;
7756 1658 break;
7757 8595 case POP_JUMP_IF_NOT_NONE:
7758 8595 last->i_opcode = is_forward ?
7759
2/2
✓ Branch 0 taken 8354 times.
✓ Branch 1 taken 241 times.
 8595 POP_JUMP_FORWARD_IF_NOT_NONE : POP_JUMP_BACKWARD_IF_NOT_NONE;
7760 8595 break;
7761 11618 case POP_JUMP_IF_NONE:
7762 11618 last->i_opcode = is_forward ?
7763
2/2
✓ Branch 0 taken 10911 times.
✓ Branch 1 taken 707 times.
 11618 POP_JUMP_FORWARD_IF_NONE : POP_JUMP_BACKWARD_IF_NONE;
7764 11618 break;
7765 144917 case POP_JUMP_IF_FALSE:
7766 144917 last->i_opcode = is_forward ?
7767
2/2
✓ Branch 0 taken 134229 times.
✓ Branch 1 taken 10688 times.
 144917 POP_JUMP_FORWARD_IF_FALSE : POP_JUMP_BACKWARD_IF_FALSE;
7768 144917 break;
7769 105018 case POP_JUMP_IF_TRUE:
7770 105018 last->i_opcode = is_forward ?
7771
2/2
✓ Branch 0 taken 99908 times.
✓ Branch 1 taken 5110 times.
 105018 POP_JUMP_FORWARD_IF_TRUE : POP_JUMP_BACKWARD_IF_TRUE;
7772 105018 break;
7773 13428 case JUMP_IF_TRUE_OR_POP:
7774 case JUMP_IF_FALSE_OR_POP:
7775
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13428 times.
 13428 if (!is_forward) {
7776 /* As far as we can tell, the compiler never emits
7777 * these jumps with a backwards target. If/when this
7778 * exception is raised, we have found a use case for
7779 * a backwards version of this jump (or to replace
7780 * it with the sequence (COPY 1, POP_JUMP_IF_T/F, POP)
7781 */
7782 ✗ PyErr_Format(PyExc_SystemError,
7783 "unexpected %s jumping backwards",
7784 ✗ last->i_opcode == JUMP_IF_TRUE_OR_POP ?
7785 "JUMP_IF_TRUE_OR_POP" : "JUMP_IF_FALSE_OR_POP");
7786 }
7787 13428 break;
7788 }
7789 }
7790 }
7791 448800 }
7792
7793 static void
7794 453660 assemble_jump_offsets(basicblock *entryblock)
7795 {
7796 int bsize, totsize, extended_arg_recompile;
7797
7798 /* Compute the size of each block and fixup jump args.
7799 Replace block pointer with position in bytecode. */
7800 do {
7801 453660 totsize = 0;
7802
2/2
✓ Branch 0 taken 1412234 times.
✓ Branch 1 taken 453660 times.
 1865894 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7803 1412234 bsize = blocksize(b);
7804 1412234 b->b_offset = totsize;
7805 1412234 totsize += bsize;
7806 }
7807 453660 extended_arg_recompile = 0;
7808
2/2
✓ Branch 0 taken 1412234 times.
✓ Branch 1 taken 453660 times.
 1865894 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7809 1412234 bsize = b->b_offset;
7810
2/2
✓ Branch 0 taken 17389967 times.
✓ Branch 1 taken 1412234 times.
 18802201 for (int i = 0; i < b->b_iused; i++) {
7811 17389967 struct instr *instr = &b->b_instr[i];
7812 17389967 int isize = instr_size(instr);
7813 /* Relative jumps are computed relative to
7814 the instruction pointer after fetching
7815 the jump instruction.
7816 */
7817 17389967 bsize += isize;
7818
2/2
✓ Branch 1 taken 508695 times.
✓ Branch 2 taken 16881272 times.
 17389967 if (is_jump(instr)) {
7819 508695 instr->i_oparg = instr->i_target->b_offset;
7820
1/2
✓ Branch 1 taken 508695 times.
✗ Branch 2 not taken.
 508695 if (is_relative_jump(instr)) {
7821
2/2
✓ Branch 0 taken 96402 times.
✓ Branch 1 taken 412293 times.
 508695 if (instr->i_oparg < bsize) {
7822 assert(IS_BACKWARDS_JUMP_OPCODE(instr->i_opcode));
7823 96402 instr->i_oparg = bsize - instr->i_oparg;
7824 }
7825 else {
7826 assert(!IS_BACKWARDS_JUMP_OPCODE(instr->i_opcode));
7827 412293 instr->i_oparg -= bsize;
7828 }
7829 }
7830 else {
7831 assert(!IS_BACKWARDS_JUMP_OPCODE(instr->i_opcode));
7832 }
7833
2/2
✓ Branch 1 taken 12181 times.
✓ Branch 2 taken 496514 times.
 508695 if (instr_size(instr) != isize) {
7834 12181 extended_arg_recompile = 1;
7835 }
7836 }
7837 }
7838 }
7839
7840 /* XXX: This is an awful hack that could hurt performance, but
7841 on the bright side it should work until we come up
7842 with a better solution.
7843
7844 The issue is that in the first loop blocksize() is called
7845 which calls instr_size() which requires i_oparg be set
7846 appropriately. There is a bootstrap problem because
7847 i_oparg is calculated in the second loop above.
7848
7849 So we loop until we stop seeing new EXTENDED_ARGs.
7850 The only EXTENDED_ARGs that could be popping up are
7851 ones in jump instructions. So this should converge
7852 fairly quickly.
7853 */
7854
2/2
✓ Branch 0 taken 4860 times.
✓ Branch 1 taken 448800 times.
 453660 } while (extended_arg_recompile);
7855 448800 }
7856
7857
7858 // Ensure each basicblock is only put onto the stack once.
7859 #define MAYBE_PUSH(B) do { \
7860 if ((B)->b_visited == 0) { \
7861 *(*stack_top)++ = (B); \
7862 (B)->b_visited = 1; \
7863 } \
7864 } while (0)
7865
7866 static void
7867 9620135 scan_block_for_local(int target, basicblock *b, bool unsafe_to_start,
7868 basicblock ***stack_top)
7869 {
7870 9620135 bool unsafe = unsafe_to_start;
7871
2/2
✓ Branch 0 taken 1775622210 times.
✓ Branch 1 taken 9620135 times.
 1785242345 for (int i = 0; i < b->b_iused; i++) {
7872 1775622210 struct instr *instr = &b->b_instr[i];
7873 assert(instr->i_opcode != EXTENDED_ARG);
7874 assert(instr->i_opcode != EXTENDED_ARG_QUICK);
7875 assert(instr->i_opcode != LOAD_FAST__LOAD_FAST);
7876 assert(instr->i_opcode != STORE_FAST__LOAD_FAST);
7877 assert(instr->i_opcode != LOAD_CONST__LOAD_FAST);
7878 assert(instr->i_opcode != STORE_FAST__STORE_FAST);
7879 assert(instr->i_opcode != LOAD_FAST__LOAD_CONST);
7880
4/4
✓ Branch 0 taken 356649824 times.
✓ Branch 1 taken 1418972386 times.
✓ Branch 2 taken 1596583 times.
✓ Branch 3 taken 355053241 times.
 1775622210 if (unsafe && instr->i_except != NULL) {
7881
2/2
✓ Branch 0 taken 101986 times.
✓ Branch 1 taken 1494597 times.
 1596583 MAYBE_PUSH(instr->i_except);
7882 }
7883
2/2
✓ Branch 0 taken 1765878675 times.
✓ Branch 1 taken 9743535 times.
 1775622210 if (instr->i_oparg != target) {
7884 1765878675 continue;
7885 }
7886
4/5
✗ Branch 0 not taken.
✓ Branch 1 taken 2643931 times.
✓ Branch 2 taken 879267 times.
✓ Branch 3 taken 3401 times.
✓ Branch 4 taken 6216936 times.
 9743535 switch (instr->i_opcode) {
7887 ✗ case LOAD_FAST_CHECK:
7888 // if this doesn't raise, then var is defined
7889 ✗ unsafe = false;
7890 ✗ break;
7891 2643931 case LOAD_FAST:
7892
2/2
✓ Branch 0 taken 2759 times.
✓ Branch 1 taken 2641172 times.
 2643931 if (unsafe) {
7893 2759 instr->i_opcode = LOAD_FAST_CHECK;
7894 }
7895 2643931 unsafe = false;
7896 2643931 break;
7897 879267 case STORE_FAST:
7898 879267 unsafe = false;
7899 879267 break;
7900 3401 case DELETE_FAST:
7901 3401 unsafe = true;
7902 3401 break;
7903 }
7904 }
7905
2/2
✓ Branch 0 taken 2135144 times.
✓ Branch 1 taken 7484991 times.
 9620135 if (unsafe) {
7906 // unsafe at end of this block,
7907 // so unsafe at start of next blocks
7908
4/4
✓ Branch 0 taken 2029748 times.
✓ Branch 1 taken 105396 times.
✓ Branch 3 taken 1421646 times.
✓ Branch 4 taken 608102 times.
 2135144 if (b->b_next && BB_HAS_FALLTHROUGH(b)) {
7909
2/2
✓ Branch 0 taken 1259391 times.
✓ Branch 1 taken 162255 times.
 1421646 MAYBE_PUSH(b->b_next);
7910 }
7911
2/2
✓ Branch 0 taken 2133400 times.
✓ Branch 1 taken 1744 times.
 2135144 if (b->b_iused > 0) {
7912 2133400 struct instr *last = &b->b_instr[b->b_iused-1];
7913
2/2
✓ Branch 1 taken 1143123 times.
✓ Branch 2 taken 990277 times.
 2133400 if (is_jump(last)) {
7914 assert(last->i_target != NULL);
7915
2/2
✓ Branch 0 taken 803178 times.
✓ Branch 1 taken 339945 times.
 1143123 MAYBE_PUSH(last->i_target);
7916 }
7917 }
7918 }
7919 9620135 }
7920 #undef MAYBE_PUSH
7921
7922 static int
7923 448800 add_checks_for_loads_of_unknown_variables(basicblock *entryblock,
7924 struct compiler *c)
7925 {
7926 448800 basicblock **stack = make_cfg_traversal_stack(entryblock);
7927
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (stack == NULL) {
7928 ✗ return -1;
7929 }
7930 448800 Py_ssize_t nparams = PyList_GET_SIZE(c->u->u_ste->ste_varnames);
7931 448800 int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
7932
2/2
✓ Branch 0 taken 1258630 times.
✓ Branch 1 taken 448800 times.
 1707430 for (int target = 0; target < nlocals; target++) {
7933
2/2
✓ Branch 0 taken 7170880 times.
✓ Branch 1 taken 1258630 times.
 8429510 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7934 7170880 b->b_visited = 0;
7935 }
7936 1258630 basicblock **stack_top = stack;
7937
7938 // First pass: find the relevant DFS starting points:
7939 // the places where "being uninitialized" originates,
7940 // which are the entry block and any DELETE_FAST statements.
7941
2/2
✓ Branch 0 taken 284700 times.
✓ Branch 1 taken 973930 times.
 1258630 if (target >= nparams) {
7942 // only non-parameter locals start out uninitialized.
7943 284700 *(stack_top++) = entryblock;
7944 284700 entryblock->b_visited = 1;
7945 }
7946
2/2
✓ Branch 0 taken 7170880 times.
✓ Branch 1 taken 1258630 times.
 8429510 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
7947 7170880 scan_block_for_local(target, b, false, &stack_top);
7948 }
7949
7950 // Second pass: Depth-first search to propagate uncertainty
7951
2/2
✓ Branch 0 taken 2449255 times.
✓ Branch 1 taken 1258630 times.
 3707885 while (stack_top > stack) {
7952 2449255 basicblock *b = *--stack_top;
7953 2449255 scan_block_for_local(target, b, true, &stack_top);
7954 }
7955 }
7956 448800 PyMem_Free(stack);
7957 448800 return 0;
7958 }
7959
7960 static PyObject *
7961 448800 dict_keys_inorder(PyObject *dict, Py_ssize_t offset)
7962 {
7963 PyObject *tuple, *k, *v;
7964 448800 Py_ssize_t i, pos = 0, size = PyDict_GET_SIZE(dict);
7965
7966 448800 tuple = PyTuple_New(size);
7967
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (tuple == NULL)
7968 ✗ return NULL;
7969
2/2
✓ Branch 1 taken 1448588 times.
✓ Branch 2 taken 448800 times.
 1897388 while (PyDict_Next(dict, &pos, &k, &v)) {
7970 1448588 i = PyLong_AS_LONG(v);
7971 1448588 Py_INCREF(k);
7972 assert((i - offset) < size);
7973 assert((i - offset) >= 0);
7974 1448588 PyTuple_SET_ITEM(tuple, i - offset, k);
7975 }
7976 448800 return tuple;
7977 }
7978
7979 static PyObject *
7980 448800 consts_dict_keys_inorder(PyObject *dict)
7981 {
7982 PyObject *consts, *k, *v;
7983 448800 Py_ssize_t i, pos = 0, size = PyDict_GET_SIZE(dict);
7984
7985 448800 consts = PyList_New(size); /* PyCode_Optimize() requires a list */
7986
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (consts == NULL)
7987 ✗ return NULL;
7988
2/2
✓ Branch 1 taken 1367301 times.
✓ Branch 2 taken 448800 times.
 1816101 while (PyDict_Next(dict, &pos, &k, &v)) {
7989 1367301 i = PyLong_AS_LONG(v);
7990 /* The keys of the dictionary can be tuples wrapping a constant.
7991 * (see compiler_add_o and _PyCode_ConstantKey). In that case
7992 * the object we want is always second. */
7993
2/2
✓ Branch 1 taken 144132 times.
✓ Branch 2 taken 1223169 times.
 1367301 if (PyTuple_CheckExact(k)) {
7994 144132 k = PyTuple_GET_ITEM(k, 1);
7995 }
7996 1367301 Py_INCREF(k);
7997 assert(i < size);
7998 assert(i >= 0);
7999 1367301 PyList_SET_ITEM(consts, i, k);
8000 }
8001 448800 return consts;
8002 }
8003
8004 static int
8005 448800 compute_code_flags(struct compiler *c)
8006 {
8007 448800 PySTEntryObject *ste = c->u->u_ste;
8008 448800 int flags = 0;
8009
2/2
✓ Branch 0 taken 276911 times.
✓ Branch 1 taken 171889 times.
 448800 if (ste->ste_type == FunctionBlock) {
8010 276911 flags |= CO_NEWLOCALS | CO_OPTIMIZED;
8011
2/2
✓ Branch 0 taken 36500 times.
✓ Branch 1 taken 240411 times.
 276911 if (ste->ste_nested)
8012 36500 flags |= CO_NESTED;
8013
4/4
✓ Branch 0 taken 8286 times.
✓ Branch 1 taken 268625 times.
✓ Branch 2 taken 8278 times.
✓ Branch 3 taken 8 times.
 276911 if (ste->ste_generator && !ste->ste_coroutine)
8014 8278 flags |= CO_GENERATOR;
8015
4/4
✓ Branch 0 taken 268625 times.
✓ Branch 1 taken 8286 times.
✓ Branch 2 taken 1098 times.
✓ Branch 3 taken 267527 times.
 276911 if (!ste->ste_generator && ste->ste_coroutine)
8016 1098 flags |= CO_COROUTINE;
8017
4/4
✓ Branch 0 taken 8286 times.
✓ Branch 1 taken 268625 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 8278 times.
 276911 if (ste->ste_generator && ste->ste_coroutine)
8018 8 flags |= CO_ASYNC_GENERATOR;
8019
2/2
✓ Branch 0 taken 7353 times.
✓ Branch 1 taken 269558 times.
 276911 if (ste->ste_varargs)
8020 7353 flags |= CO_VARARGS;
8021
2/2
✓ Branch 0 taken 9936 times.
✓ Branch 1 taken 266975 times.
 276911 if (ste->ste_varkeywords)
8022 9936 flags |= CO_VARKEYWORDS;
8023 }
8024
8025 /* (Only) inherit compilerflags in PyCF_MASK */
8026 448800 flags |= (c->c_flags->cf_flags & PyCF_MASK);
8027
8028
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 448800 if ((IS_TOP_LEVEL_AWAIT(c)) &&
8029 ✗ ste->ste_coroutine &&
8030 ✗ !ste->ste_generator) {
8031 ✗ flags |= CO_COROUTINE;
8032 }
8033
8034 448800 return flags;
8035 }
8036
8037 // Merge *obj* with constant cache.
8038 // Unlike merge_consts_recursive(), this function doesn't work recursively.
8039 static int
8040 2712165 merge_const_one(PyObject *const_cache, PyObject **obj)
8041 {
8042 2712165 PyDict_CheckExact(const_cache);
8043 2712165 PyObject *key = _PyCode_ConstantKey(*obj);
8044
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2712165 times.
 2712165 if (key == NULL) {
8045 ✗ return 0;
8046 }
8047
8048 // t is borrowed reference
8049 2712165 PyObject *t = PyDict_SetDefault(const_cache, key, key);
8050 2712165 Py_DECREF(key);
8051
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2712165 times.
 2712165 if (t == NULL) {
8052 ✗ return 0;
8053 }
8054
2/2
✓ Branch 0 taken 2088122 times.
✓ Branch 1 taken 624043 times.
 2712165 if (t == key) { // obj is new constant.
8055 2088122 return 1;
8056 }
8057
8058
1/2
✓ Branch 1 taken 624043 times.
✗ Branch 2 not taken.
 624043 if (PyTuple_CheckExact(t)) {
8059 // t is still borrowed reference
8060 624043 t = PyTuple_GET_ITEM(t, 1);
8061 }
8062
8063 624043 Py_INCREF(t);
8064 624043 Py_DECREF(*obj);
8065 624043 *obj = t;
8066 624043 return 1;
8067 }
8068
8069 // This is in codeobject.c.
8070 extern void _Py_set_localsplus_info(int, PyObject *, unsigned char,
8071 PyObject *, PyObject *);
8072
8073 static void
8074 448800 compute_localsplus_info(struct compiler *c, int nlocalsplus,
8075 PyObject *names, PyObject *kinds)
8076 {
8077 PyObject *k, *v;
8078 448800 Py_ssize_t pos = 0;
8079
2/2
✓ Branch 1 taken 1258630 times.
✓ Branch 2 taken 448800 times.
 1707430 while (PyDict_Next(c->u->u_varnames, &pos, &k, &v)) {
8080 1258630 int offset = (int)PyLong_AS_LONG(v);
8081 assert(offset >= 0);
8082 assert(offset < nlocalsplus);
8083 // For now we do not distinguish arg kinds.
8084 1258630 _PyLocals_Kind kind = CO_FAST_LOCAL;
8085
2/2
✓ Branch 1 taken 9373 times.
✓ Branch 2 taken 1249257 times.
 1258630 if (PyDict_GetItem(c->u->u_cellvars, k) != NULL) {
8086 9373 kind |= CO_FAST_CELL;
8087 }
8088 1258630 _Py_set_localsplus_info(offset, k, kind, names, kinds);
8089 }
8090 448800 int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
8091
8092 // This counter mirrors the fix done in fix_cell_offsets().
8093 448800 int numdropped = 0;
8094 448800 pos = 0;
8095
2/2
✓ Branch 1 taken 20549 times.
✓ Branch 2 taken 448800 times.
 469349 while (PyDict_Next(c->u->u_cellvars, &pos, &k, &v)) {
8096
2/2
✓ Branch 1 taken 9373 times.
✓ Branch 2 taken 11176 times.
 20549 if (PyDict_GetItem(c->u->u_varnames, k) != NULL) {
8097 // Skip cells that are already covered by locals.
8098 9373 numdropped += 1;
8099 9373 continue;
8100 }
8101 11176 int offset = (int)PyLong_AS_LONG(v);
8102 assert(offset >= 0);
8103 11176 offset += nlocals - numdropped;
8104 assert(offset < nlocalsplus);
8105 11176 _Py_set_localsplus_info(offset, k, CO_FAST_CELL, names, kinds);
8106 }
8107
8108 448800 pos = 0;
8109
2/2
✓ Branch 1 taken 27419 times.
✓ Branch 2 taken 448800 times.
 476219 while (PyDict_Next(c->u->u_freevars, &pos, &k, &v)) {
8110 27419 int offset = (int)PyLong_AS_LONG(v);
8111 assert(offset >= 0);
8112 27419 offset += nlocals - numdropped;
8113 assert(offset < nlocalsplus);
8114 27419 _Py_set_localsplus_info(offset, k, CO_FAST_FREE, names, kinds);
8115 }
8116 448800 }
8117
8118 static PyCodeObject *
8119 448800 makecode(struct compiler *c, struct assembler *a, PyObject *constslist,
8120 int maxdepth, int nlocalsplus, int code_flags)
8121 {
8122 448800 PyCodeObject *co = NULL;
8123 448800 PyObject *names = NULL;
8124 448800 PyObject *consts = NULL;
8125 448800 PyObject *localsplusnames = NULL;
8126 448800 PyObject *localspluskinds = NULL;
8127
8128 448800 names = dict_keys_inorder(c->u->u_names, 0);
8129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!names) {
8130 ✗ goto error;
8131 }
8132
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!merge_const_one(c->c_const_cache, &names)) {
8133 ✗ goto error;
8134 }
8135
8136 448800 consts = PyList_AsTuple(constslist); /* PyCode_New requires a tuple */
8137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (consts == NULL) {
8138 ✗ goto error;
8139 }
8140
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!merge_const_one(c->c_const_cache, &consts)) {
8141 ✗ goto error;
8142 }
8143
8144 assert(c->u->u_posonlyargcount < INT_MAX);
8145 assert(c->u->u_argcount < INT_MAX);
8146 assert(c->u->u_kwonlyargcount < INT_MAX);
8147 448800 int posonlyargcount = (int)c->u->u_posonlyargcount;
8148 448800 int posorkwargcount = (int)c->u->u_argcount;
8149 assert(INT_MAX - posonlyargcount - posorkwargcount > 0);
8150 448800 int kwonlyargcount = (int)c->u->u_kwonlyargcount;
8151
8152 448800 localsplusnames = PyTuple_New(nlocalsplus);
8153
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (localsplusnames == NULL) {
8154 ✗ goto error;
8155 }
8156 448800 localspluskinds = PyBytes_FromStringAndSize(NULL, nlocalsplus);
8157
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (localspluskinds == NULL) {
8158 ✗ goto error;
8159 }
8160 448800 compute_localsplus_info(c, nlocalsplus, localsplusnames, localspluskinds);
8161
8162 897600 struct _PyCodeConstructor con = {
8163 448800 .filename = c->c_filename,
8164 448800 .name = c->u->u_name,
8165
2/2
✓ Branch 0 taken 292115 times.
✓ Branch 1 taken 156685 times.
 448800 .qualname = c->u->u_qualname ? c->u->u_qualname : c->u->u_name,
8166 .flags = code_flags,
8167
8168 448800 .code = a->a_bytecode,
8169 448800 .firstlineno = c->u->u_firstlineno,
8170 448800 .linetable = a->a_linetable,
8171
8172 .consts = consts,
8173 .names = names,
8174
8175 .localsplusnames = localsplusnames,
8176 .localspluskinds = localspluskinds,
8177
8178 448800 .argcount = posonlyargcount + posorkwargcount,
8179 .posonlyargcount = posonlyargcount,
8180 .kwonlyargcount = kwonlyargcount,
8181
8182 .stacksize = maxdepth,
8183
8184 448800 .exceptiontable = a->a_except_table,
8185 };
8186
8187
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (_PyCode_Validate(&con) < 0) {
8188 ✗ goto error;
8189 }
8190
8191
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!merge_const_one(c->c_const_cache, &localsplusnames)) {
8192 ✗ goto error;
8193 }
8194 448800 con.localsplusnames = localsplusnames;
8195
8196 448800 co = _PyCode_New(&con);
8197
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 if (co == NULL) {
8198 ✗ goto error;
8199 }
8200
8201 448800 error:
8202 448800 Py_XDECREF(names);
8203 448800 Py_XDECREF(consts);
8204 448800 Py_XDECREF(localsplusnames);
8205 448800 Py_XDECREF(localspluskinds);
8206 448800 return co;
8207 }
8208
8209
8210 /* For debugging purposes only */
8211 #if 0
8212 static void
8213 dump_instr(struct instr *i)
8214 {
8215 const char *jrel = (is_relative_jump(i)) ? "jrel " : "";
8216 const char *jabs = (is_jump(i) && !is_relative_jump(i))? "jabs " : "";
8217
8218 char arg[128];
8219
8220 *arg = '\0';
8221 if (HAS_ARG(i->i_opcode)) {
8222 sprintf(arg, "arg: %d ", i->i_oparg);
8223 }
8224 if (is_jump(i)) {
8225 sprintf(arg, "target: %p ", i->i_target);
8226 }
8227 if (is_block_push(i)) {
8228 sprintf(arg, "except_target: %p ", i->i_target);
8229 }
8230 fprintf(stderr, "line: %d, opcode: %d %s%s%s\n",
8231 i->i_loc.lineno, i->i_opcode, arg, jabs, jrel);
8232 }
8233
8234 static void
8235 dump_basicblock(const basicblock *b)
8236 {
8237 const char *b_return = basicblock_returns(b) ? "return " : "";
8238 fprintf(stderr, "[%d %d %d %p] used: %d, depth: %d, offset: %d %s\n",
8239 b->b_cold, b->b_warm, BB_NO_FALLTHROUGH(b), b, b->b_iused,
8240 b->b_startdepth, b->b_offset, b_return);
8241 if (b->b_instr) {
8242 int i;
8243 for (i = 0; i < b->b_iused; i++) {
8244 fprintf(stderr, " [%02d] ", i);
8245 dump_instr(b->b_instr + i);
8246 }
8247 }
8248 }
8249 #endif
8250
8251
8252 static int
8253 normalize_basic_block(basicblock *bb);
8254
8255 static int
8256 optimize_cfg(basicblock *entryblock, PyObject *consts, PyObject *const_cache);
8257
8258 static int
8259 trim_unused_consts(basicblock *entryblock, PyObject *consts);
8260
8261 /* Duplicates exit BBs, so that line numbers can be propagated to them */
8262 static int
8263 duplicate_exits_without_lineno(basicblock *entryblock);
8264
8265 static int
8266 extend_block(basicblock *bb);
8267
8268 static int *
8269 448800 build_cellfixedoffsets(struct compiler *c)
8270 {
8271 448800 int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
8272 448800 int ncellvars = (int)PyDict_GET_SIZE(c->u->u_cellvars);
8273 448800 int nfreevars = (int)PyDict_GET_SIZE(c->u->u_freevars);
8274
8275 448800 int noffsets = ncellvars + nfreevars;
8276
1/2
✓ Branch 0 taken 448800 times.
✗ Branch 1 not taken.
 448800 int *fixed = PyMem_New(int, noffsets);
8277
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (fixed == NULL) {
8278 ✗ PyErr_NoMemory();
8279 ✗ return NULL;
8280 }
8281
2/2
✓ Branch 0 taken 47968 times.
✓ Branch 1 taken 448800 times.
 496768 for (int i = 0; i < noffsets; i++) {
8282 47968 fixed[i] = nlocals + i;
8283 }
8284
8285 PyObject *varname, *cellindex;
8286 448800 Py_ssize_t pos = 0;
8287
2/2
✓ Branch 1 taken 20549 times.
✓ Branch 2 taken 448800 times.
 469349 while (PyDict_Next(c->u->u_cellvars, &pos, &varname, &cellindex)) {
8288 20549 PyObject *varindex = PyDict_GetItem(c->u->u_varnames, varname);
8289
2/2
✓ Branch 0 taken 9373 times.
✓ Branch 1 taken 11176 times.
 20549 if (varindex != NULL) {
8290 assert(PyLong_AS_LONG(cellindex) < INT_MAX);
8291 assert(PyLong_AS_LONG(varindex) < INT_MAX);
8292 9373 int oldindex = (int)PyLong_AS_LONG(cellindex);
8293 9373 int argoffset = (int)PyLong_AS_LONG(varindex);
8294 9373 fixed[oldindex] = argoffset;
8295 }
8296 }
8297
8298 448800 return fixed;
8299 }
8300
8301 static inline int
8302 57684 insert_instruction(basicblock *block, int pos, struct instr *instr) {
8303
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 57684 times.
 57684 if (basicblock_next_instr(block) < 0) {
8304 ✗ return -1;
8305 }
8306
2/2
✓ Branch 0 taken 965206 times.
✓ Branch 1 taken 57684 times.
 1022890 for (int i = block->b_iused-1; i > pos; i--) {
8307 965206 block->b_instr[i] = block->b_instr[i-1];
8308 }
8309 57684 block->b_instr[pos] = *instr;
8310 57684 return 0;
8311 }
8312
8313 static int
8314 448800 insert_prefix_instructions(struct compiler *c, basicblock *entryblock,
8315 int *fixed, int nfreevars, int code_flags)
8316 {
8317 assert(c->u->u_firstlineno > 0);
8318
8319 /* Add the generator prefix instructions. */
8320
2/2
✓ Branch 0 taken 9384 times.
✓ Branch 1 taken 439416 times.
 448800 if (code_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {
8321 9384 struct instr make_gen = {
8322 .i_opcode = RETURN_GENERATOR,
8323 .i_oparg = 0,
8324 9384 .i_loc = LOCATION(c->u->u_firstlineno, c->u->u_firstlineno, -1, -1),
8325 .i_target = NULL,
8326 };
8327
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9384 times.
 9384 if (insert_instruction(entryblock, 0, &make_gen) < 0) {
8328 ✗ return -1;
8329 }
8330 9384 struct instr pop_top = {
8331 .i_opcode = POP_TOP,
8332 .i_oparg = 0,
8333 .i_loc = NO_LOCATION,
8334 .i_target = NULL,
8335 };
8336
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9384 times.
 9384 if (insert_instruction(entryblock, 1, &pop_top) < 0) {
8337 ✗ return -1;
8338 }
8339 }
8340
8341 /* Set up cells for any variable that escapes, to be put in a closure. */
8342 448800 const int ncellvars = (int)PyDict_GET_SIZE(c->u->u_cellvars);
8343
2/2
✓ Branch 0 taken 12091 times.
✓ Branch 1 taken 436709 times.
 448800 if (ncellvars) {
8344 // c->u->u_cellvars has the cells out of order so we sort them
8345 // before adding the MAKE_CELL instructions. Note that we
8346 // adjust for arg cells, which come first.
8347 12091 const int nvars = ncellvars + (int)PyDict_GET_SIZE(c->u->u_varnames);
8348 12091 int *sorted = PyMem_RawCalloc(nvars, sizeof(int));
8349
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12091 times.
 12091 if (sorted == NULL) {
8350 ✗ PyErr_NoMemory();
8351 ✗ return -1;
8352 }
8353
2/2
✓ Branch 0 taken 20549 times.
✓ Branch 1 taken 12091 times.
 32640 for (int i = 0; i < ncellvars; i++) {
8354 20549 sorted[fixed[i]] = i + 1;
8355 }
8356
2/2
✓ Branch 0 taken 72358 times.
✓ Branch 1 taken 12091 times.
 84449 for (int i = 0, ncellsused = 0; ncellsused < ncellvars; i++) {
8357 72358 int oldindex = sorted[i] - 1;
8358
2/2
✓ Branch 0 taken 51809 times.
✓ Branch 1 taken 20549 times.
 72358 if (oldindex == -1) {
8359 51809 continue;
8360 }
8361 20549 struct instr make_cell = {
8362 .i_opcode = MAKE_CELL,
8363 // This will get fixed in offset_derefs().
8364 .i_oparg = oldindex,
8365 .i_loc = NO_LOCATION,
8366 .i_target = NULL,
8367 };
8368
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 20549 times.
 20549 if (insert_instruction(entryblock, ncellsused, &make_cell) < 0) {
8369 ✗ return -1;
8370 }
8371 20549 ncellsused += 1;
8372 }
8373 12091 PyMem_RawFree(sorted);
8374 }
8375
8376
2/2
✓ Branch 0 taken 18367 times.
✓ Branch 1 taken 430433 times.
 448800 if (nfreevars) {
8377 18367 struct instr copy_frees = {
8378 .i_opcode = COPY_FREE_VARS,
8379 .i_oparg = nfreevars,
8380 .i_loc = NO_LOCATION,
8381 .i_target = NULL,
8382 };
8383
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 18367 times.
 18367 if (insert_instruction(entryblock, 0, &copy_frees) < 0) {
8384 ✗ return -1;
8385 }
8386
8387 }
8388
8389 448800 return 0;
8390 }
8391
8392 /* Make sure that all returns have a line number, even if early passes
8393 * have failed to propagate a correct line number.
8394 * The resulting line number may not be correct according to PEP 626,
8395 * but should be "good enough", and no worse than in older versions. */
8396 static void
8397 448800 guarantee_lineno_for_exits(basicblock *entryblock, int firstlineno) {
8398 448800 int lineno = firstlineno;
8399 assert(lineno > 0);
8400
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
8401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1262784 times.
 1262784 if (b->b_iused == 0) {
8402 ✗ continue;
8403 }
8404 1262784 struct instr *last = &b->b_instr[b->b_iused-1];
8405
2/2
✓ Branch 0 taken 19788 times.
✓ Branch 1 taken 1242996 times.
 1262784 if (last->i_loc.lineno < 0) {
8406
2/2
✓ Branch 0 taken 289 times.
✓ Branch 1 taken 19499 times.
 19788 if (last->i_opcode == RETURN_VALUE) {
8407
2/2
✓ Branch 0 taken 867 times.
✓ Branch 1 taken 289 times.
 1156 for (int i = 0; i < b->b_iused; i++) {
8408 assert(b->b_instr[i].i_loc.lineno < 0);
8409
8410 867 b->b_instr[i].i_loc.lineno = lineno;
8411 }
8412 }
8413 }
8414 else {
8415 1242996 lineno = last->i_loc.lineno;
8416 }
8417 }
8418 448800 }
8419
8420 static int
8421 448800 fix_cell_offsets(struct compiler *c, basicblock *entryblock, int *fixedmap)
8422 {
8423 448800 int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
8424 448800 int ncellvars = (int)PyDict_GET_SIZE(c->u->u_cellvars);
8425 448800 int nfreevars = (int)PyDict_GET_SIZE(c->u->u_freevars);
8426 448800 int noffsets = ncellvars + nfreevars;
8427
8428 // First deal with duplicates (arg cells).
8429 448800 int numdropped = 0;
8430
2/2
✓ Branch 0 taken 47968 times.
✓ Branch 1 taken 448800 times.
 496768 for (int i = 0; i < noffsets ; i++) {
8431
2/2
✓ Branch 0 taken 38595 times.
✓ Branch 1 taken 9373 times.
 47968 if (fixedmap[i] == i + nlocals) {
8432 38595 fixedmap[i] -= numdropped;
8433 }
8434 else {
8435 // It was a duplicate (cell/arg).
8436 9373 numdropped += 1;
8437 }
8438 }
8439
8440 // Then update offsets, either relative to locals or by cell2arg.
8441
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
8442
2/2
✓ Branch 0 taken 15792134 times.
✓ Branch 1 taken 1366225 times.
 17158359 for (int i = 0; i < b->b_iused; i++) {
8443 15792134 struct instr *inst = &b->b_instr[i];
8444 // This is called before extended args are generated.
8445 assert(inst->i_opcode != EXTENDED_ARG);
8446 assert(inst->i_opcode != EXTENDED_ARG_QUICK);
8447 15792134 int oldoffset = inst->i_oparg;
8448
2/2
✓ Branch 0 taken 137829 times.
✓ Branch 1 taken 15654305 times.
 15792134 switch(inst->i_opcode) {
8449 137829 case MAKE_CELL:
8450 case LOAD_CLOSURE:
8451 case LOAD_DEREF:
8452 case STORE_DEREF:
8453 case DELETE_DEREF:
8454 case LOAD_CLASSDEREF:
8455 assert(oldoffset >= 0);
8456 assert(oldoffset < noffsets);
8457 assert(fixedmap[oldoffset] >= 0);
8458 137829 inst->i_oparg = fixedmap[oldoffset];
8459 }
8460 }
8461 }
8462
8463 448800 return numdropped;
8464 }
8465
8466 static void
8467 propagate_line_numbers(basicblock *entryblock);
8468
8469 static void
8470 eliminate_empty_basic_blocks(basicblock *entryblock);
8471
8472
8473 static void
8474 448800 remove_redundant_jumps(basicblock *entryblock) {
8475 /* If a non-empty block ends with a jump instruction, check if the next
8476 * non-empty block reached through normal flow control is the target
8477 * of that jump. If it is, then the jump instruction is redundant and
8478 * can be deleted.
8479 */
8480 448800 int removed = 0;
8481
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
8482
1/2
✓ Branch 0 taken 1262806 times.
✗ Branch 1 not taken.
 1262806 if (b->b_iused > 0) {
8483 1262806 struct instr *b_last_instr = &b->b_instr[b->b_iused - 1];
8484 assert(!IS_ASSEMBLER_OPCODE(b_last_instr->i_opcode));
8485
2/2
✓ Branch 0 taken 1167012 times.
✓ Branch 1 taken 95794 times.
 1262806 if (b_last_instr->i_opcode == JUMP ||
8486
2/2
✓ Branch 0 taken 1658 times.
✓ Branch 1 taken 1165354 times.
 1167012 b_last_instr->i_opcode == JUMP_NO_INTERRUPT) {
8487
2/2
✓ Branch 0 taken 9097 times.
✓ Branch 1 taken 88355 times.
 97452 if (b_last_instr->i_target == b->b_next) {
8488 assert(b->b_next->b_iused);
8489 9097 b_last_instr->i_opcode = NOP;
8490 9097 removed++;
8491 }
8492 }
8493 }
8494 }
8495
2/2
✓ Branch 0 taken 7054 times.
✓ Branch 1 taken 441746 times.
 448800 if (removed) {
8496 7054 eliminate_empty_basic_blocks(entryblock);
8497 }
8498 448800 }
8499
8500 static PyCodeObject *
8501 448800 assemble(struct compiler *c, int addNone)
8502 {
8503 448800 PyCodeObject *co = NULL;
8504 448800 PyObject *consts = NULL;
8505
8506 448800 int code_flags = compute_code_flags(c);
8507
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (code_flags < 0) {
8508 ✗ return NULL;
8509 }
8510
8511 /* Make sure every block that falls off the end returns None. */
8512
2/2
✓ Branch 1 taken 223810 times.
✓ Branch 2 taken 224990 times.
 448800 if (!basicblock_returns(c->u->u_curblock)) {
8513 223810 UNSET_LOC(c);
8514
2/2
✓ Branch 0 taken 107793 times.
✓ Branch 1 taken 116017 times.
 223810 if (addNone)
8515
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 107793 times.
 107793 ADDOP_LOAD_CONST(c, Py_None);
8516
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 223810 times.
 223810 ADDOP(c, RETURN_VALUE);
8517 }
8518
8519
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
8520
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1366225 times.
 1366225 if (normalize_basic_block(b)) {
8521 ✗ return NULL;
8522 }
8523 }
8524
8525
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
8526
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1366225 times.
 1366225 if (extend_block(b)) {
8527 ✗ return NULL;
8528 }
8529 }
8530
8531 assert(PyDict_GET_SIZE(c->u->u_varnames) < INT_MAX);
8532 assert(PyDict_GET_SIZE(c->u->u_cellvars) < INT_MAX);
8533 assert(PyDict_GET_SIZE(c->u->u_freevars) < INT_MAX);
8534 448800 int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
8535 448800 int ncellvars = (int)PyDict_GET_SIZE(c->u->u_cellvars);
8536 448800 int nfreevars = (int)PyDict_GET_SIZE(c->u->u_freevars);
8537 assert(INT_MAX - nlocals - ncellvars > 0);
8538 assert(INT_MAX - nlocals - ncellvars - nfreevars > 0);
8539 448800 int nlocalsplus = nlocals + ncellvars + nfreevars;
8540 448800 int *cellfixedoffsets = build_cellfixedoffsets(c);
8541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (cellfixedoffsets == NULL) {
8542 ✗ goto error;
8543 }
8544
8545 448800 int nblocks = 0;
8546 448800 basicblock *entryblock = NULL;
8547
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
8548 1366225 nblocks++;
8549 1366225 entryblock = b;
8550 }
8551 assert(entryblock != NULL);
8552
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if ((size_t)nblocks > SIZE_MAX / sizeof(basicblock *)) {
8553 ✗ PyErr_NoMemory();
8554 ✗ goto error;
8555 }
8556
8557 /* Set firstlineno if it wasn't explicitly set. */
8558
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (!c->u->u_firstlineno) {
8559 ✗ if (entryblock->b_instr && entryblock->b_instr->i_loc.lineno) {
8560 ✗ c->u->u_firstlineno = entryblock->b_instr->i_loc.lineno;
8561 }
8562 else {
8563 ✗ c->u->u_firstlineno = 1;
8564 }
8565 }
8566
8567 // This must be called before fix_cell_offsets().
8568
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (insert_prefix_instructions(c, entryblock, cellfixedoffsets, nfreevars, code_flags)) {
8569 ✗ goto error;
8570 }
8571
8572 448800 int numdropped = fix_cell_offsets(c, entryblock, cellfixedoffsets);
8573 448800 PyMem_Free(cellfixedoffsets); // At this point we're done with it.
8574 448800 cellfixedoffsets = NULL;
8575
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (numdropped < 0) {
8576 ✗ goto error;
8577 }
8578 448800 nlocalsplus -= numdropped;
8579
8580 448800 consts = consts_dict_keys_inorder(c->u->u_consts);
8581
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (consts == NULL) {
8582 ✗ goto error;
8583 }
8584
8585
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (optimize_cfg(entryblock, consts, c->c_const_cache)) {
8586 ✗ goto error;
8587 }
8588
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (duplicate_exits_without_lineno(entryblock)) {
8589 ✗ return NULL;
8590 }
8591
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (trim_unused_consts(entryblock, consts)) {
8592 ✗ goto error;
8593 }
8594 448800 propagate_line_numbers(entryblock);
8595 448800 guarantee_lineno_for_exits(entryblock, c->u->u_firstlineno);
8596
8597 448800 int maxdepth = stackdepth(entryblock, code_flags);
8598
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (maxdepth < 0) {
8599 ✗ goto error;
8600 }
8601
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (maxdepth > MAX_ALLOWED_STACK_USE) {
8602 ✗ PyErr_Format(PyExc_SystemError,
8603 "excessive stack use: stack is %d deep",
8604 maxdepth);
8605 ✗ goto error;
8606 }
8607
8608
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (label_exception_targets(entryblock)) {
8609 ✗ goto error;
8610 }
8611 448800 convert_exception_handlers_to_nops(entryblock);
8612
8613
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (push_cold_blocks_to_end(entryblock, code_flags) < 0) {
8614 ✗ goto error;
8615 }
8616
8617 448800 remove_redundant_jumps(entryblock);
8618
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
8619 1262806 clean_basic_block(b);
8620 }
8621
8622 /* Order of basic blocks must have been determined by now */
8623 448800 normalize_jumps(entryblock);
8624
8625
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (add_checks_for_loads_of_unknown_variables(entryblock, c) < 0) {
8626 ✗ goto error;
8627 }
8628
8629 /* Can't modify the bytecode after computing jump offsets. */
8630 448800 assemble_jump_offsets(entryblock);
8631
8632
8633 /* Create assembler */
8634 struct assembler a;
8635
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!assemble_init(&a, c->u->u_firstlineno))
8636 ✗ goto error;
8637
8638 /* Emit code. */
8639
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
8640
2/2
✓ Branch 0 taken 14497150 times.
✓ Branch 1 taken 1262806 times.
 15759956 for (int j = 0; j < b->b_iused; j++)
8641
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14497150 times.
 14497150 if (!assemble_emit(&a, &b->b_instr[j]))
8642 ✗ goto error;
8643 }
8644
8645 /* Emit location info */
8646 448800 a.a_lineno = c->u->u_firstlineno;
8647
2/2
✓ Branch 0 taken 1262806 times.
✓ Branch 1 taken 448800 times.
 1711606 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
8648
2/2
✓ Branch 0 taken 14497150 times.
✓ Branch 1 taken 1262806 times.
 15759956 for (int j = 0; j < b->b_iused; j++)
8649
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14497150 times.
 14497150 if (!assemble_emit_location(&a, &b->b_instr[j]))
8650 ✗ goto error;
8651 }
8652
8653
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!assemble_exception_table(&a, entryblock)) {
8654 ✗ goto error;
8655 }
8656
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (_PyBytes_Resize(&a.a_except_table, a.a_except_table_off) < 0) {
8657 ✗ goto error;
8658 }
8659
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!merge_const_one(c->c_const_cache, &a.a_except_table)) {
8660 ✗ goto error;
8661 }
8662
8663
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (_PyBytes_Resize(&a.a_linetable, a.a_location_off) < 0) {
8664 ✗ goto error;
8665 }
8666
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!merge_const_one(c->c_const_cache, &a.a_linetable)) {
8667 ✗ goto error;
8668 }
8669
8670
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (_PyBytes_Resize(&a.a_bytecode, a.a_offset * sizeof(_Py_CODEUNIT)) < 0) {
8671 ✗ goto error;
8672 }
8673
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (!merge_const_one(c->c_const_cache, &a.a_bytecode)) {
8674 ✗ goto error;
8675 }
8676
8677 448800 co = makecode(c, &a, consts, maxdepth, nlocalsplus, code_flags);
8678 448800 error:
8679 448800 Py_XDECREF(consts);
8680 448800 assemble_free(&a);
8681
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (cellfixedoffsets != NULL) {
8682 ✗ PyMem_Free(cellfixedoffsets);
8683 }
8684 448800 return co;
8685 }
8686
8687 static PyObject*
8688 69151 get_const_value(int opcode, int oparg, PyObject *co_consts)
8689 {
8690 69151 PyObject *constant = NULL;
8691 assert(HAS_CONST(opcode));
8692
1/2
✓ Branch 0 taken 69151 times.
✗ Branch 1 not taken.
 69151 if (opcode == LOAD_CONST) {
8693 69151 constant = PyList_GET_ITEM(co_consts, oparg);
8694 }
8695
8696
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69151 times.
 69151 if (constant == NULL) {
8697 ✗ PyErr_SetString(PyExc_SystemError,
8698 "Internal error: failed to get value of a constant");
8699 ✗ return NULL;
8700 }
8701 69151 Py_INCREF(constant);
8702 69151 return constant;
8703 }
8704
8705 /* Replace LOAD_CONST c1, LOAD_CONST c2 ... LOAD_CONST cn, BUILD_TUPLE n
8706 with LOAD_CONST (c1, c2, ... cn).
8707 The consts table must still be in list form so that the
8708 new constant (c1, c2, ... cn) can be appended.
8709 Called with codestr pointing to the first LOAD_CONST.
8710 */
8711 static int
8712 218588 fold_tuple_on_constants(PyObject *const_cache,
8713 struct instr *inst,
8714 int n, PyObject *consts)
8715 {
8716 /* Pre-conditions */
8717 assert(PyDict_CheckExact(const_cache));
8718 assert(PyList_CheckExact(consts));
8719 assert(inst[n].i_opcode == BUILD_TUPLE);
8720 assert(inst[n].i_oparg == n);
8721
8722
2/2
✓ Branch 0 taken 261737 times.
✓ Branch 1 taken 19365 times.
 281102 for (int i = 0; i < n; i++) {
8723
4/4
✓ Branch 0 taken 199418 times.
✓ Branch 1 taken 62319 times.
✓ Branch 2 taken 199223 times.
✓ Branch 3 taken 195 times.
 261737 if (!HAS_CONST(inst[i].i_opcode)) {
8724 199223 return 0;
8725 }
8726 }
8727
8728 /* Buildup new tuple of constants */
8729 19365 PyObject *newconst = PyTuple_New(n);
8730
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19365 times.
 19365 if (newconst == NULL) {
8731 ✗ return -1;
8732 }
8733
2/2
✓ Branch 0 taken 40759 times.
✓ Branch 1 taken 19365 times.
 60124 for (int i = 0; i < n; i++) {
8734 40759 int op = inst[i].i_opcode;
8735 40759 int arg = inst[i].i_oparg;
8736 40759 PyObject *constant = get_const_value(op, arg, consts);
8737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40759 times.
 40759 if (constant == NULL) {
8738 ✗ return -1;
8739 }
8740 40759 PyTuple_SET_ITEM(newconst, i, constant);
8741 }
8742
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19365 times.
 19365 if (merge_const_one(const_cache, &newconst) == 0) {
8743 ✗ Py_DECREF(newconst);
8744 ✗ return -1;
8745 }
8746
8747 Py_ssize_t index;
8748
2/2
✓ Branch 1 taken 634730 times.
✓ Branch 2 taken 15563 times.
 650293 for (index = 0; index < PyList_GET_SIZE(consts); index++) {
8749
2/2
✓ Branch 0 taken 3802 times.
✓ Branch 1 taken 630928 times.
 634730 if (PyList_GET_ITEM(consts, index) == newconst) {
8750 3802 break;
8751 }
8752 }
8753
2/2
✓ Branch 1 taken 15563 times.
✓ Branch 2 taken 3802 times.
 19365 if (index == PyList_GET_SIZE(consts)) {
8754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15563 times.
 15563 if ((size_t)index >= (size_t)INT_MAX - 1) {
8755 ✗ Py_DECREF(newconst);
8756 ✗ PyErr_SetString(PyExc_OverflowError, "too many constants");
8757 ✗ return -1;
8758 }
8759
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15563 times.
 15563 if (PyList_Append(consts, newconst)) {
8760 ✗ Py_DECREF(newconst);
8761 ✗ return -1;
8762 }
8763 }
8764 19365 Py_DECREF(newconst);
8765
2/2
✓ Branch 0 taken 40759 times.
✓ Branch 1 taken 19365 times.
 60124 for (int i = 0; i < n; i++) {
8766 40759 inst[i].i_opcode = NOP;
8767 }
8768 19365 inst[n].i_opcode = LOAD_CONST;
8769 19365 inst[n].i_oparg = (int)index;
8770 19365 return 0;
8771 }
8772
8773 #define VISITED (-1)
8774
8775 // Replace an arbitrary run of SWAPs and NOPs with an optimal one that has the
8776 // same effect.
8777 static int
8778 13163 swaptimize(basicblock *block, int *ix)
8779 {
8780 // NOTE: "./python -m test test_patma" serves as a good, quick stress test
8781 // for this function. Make sure to blow away cached *.pyc files first!
8782 assert(*ix < block->b_iused);
8783 13163 struct instr *instructions = &block->b_instr[*ix];
8784 // Find the length of the current sequence of SWAPs and NOPs, and record the
8785 // maximum depth of the stack manipulations:
8786 assert(instructions[0].i_opcode == SWAP);
8787 13163 int depth = instructions[0].i_oparg;
8788 13163 int len = 0;
8789 13163 int more = false;
8790 13163 int limit = block->b_iused - *ix;
8791
1/2
✓ Branch 0 taken 15094 times.
✗ Branch 1 not taken.
 15094 while (++len < limit) {
8792 15094 int opcode = instructions[len].i_opcode;
8793
2/2
✓ Branch 0 taken 1931 times.
✓ Branch 1 taken 13163 times.
 15094 if (opcode == SWAP) {
8794 1931 depth = Py_MAX(depth, instructions[len].i_oparg);
8795 1931 more = true;
8796 }
8797
1/2
✓ Branch 0 taken 13163 times.
✗ Branch 1 not taken.
 13163 else if (opcode != NOP) {
8798 13163 break;
8799 }
8800 }
8801 // It's already optimal if there's only one SWAP:
8802
2/2
✓ Branch 0 taken 11232 times.
✓ Branch 1 taken 1931 times.
 13163 if (!more) {
8803 11232 return 0;
8804 }
8805 // Create an array with elements {0, 1, 2, ..., depth - 1}:
8806 1931 int *stack = PyMem_Malloc(depth * sizeof(int));
8807
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1931 times.
 1931 if (stack == NULL) {
8808 ✗ PyErr_NoMemory();
8809 ✗ return -1;
8810 }
8811
2/2
✓ Branch 0 taken 5793 times.
✓ Branch 1 taken 1931 times.
 7724 for (int i = 0; i < depth; i++) {
8812 5793 stack[i] = i;
8813 }
8814 // Simulate the combined effect of these instructions by "running" them on
8815 // our "stack":
8816
2/2
✓ Branch 0 taken 3862 times.
✓ Branch 1 taken 1931 times.
 5793 for (int i = 0; i < len; i++) {
8817
1/2
✓ Branch 0 taken 3862 times.
✗ Branch 1 not taken.
 3862 if (instructions[i].i_opcode == SWAP) {
8818 3862 int oparg = instructions[i].i_oparg;
8819 3862 int top = stack[0];
8820 // SWAPs are 1-indexed:
8821 3862 stack[0] = stack[oparg - 1];
8822 3862 stack[oparg - 1] = top;
8823 }
8824 }
8825 // Now we can begin! Our approach here is based on a solution to a closely
8826 // related problem (https://cs.stackexchange.com/a/13938). It's easiest to
8827 // think of this algorithm as determining the steps needed to efficiently
8828 // "un-shuffle" our stack. By performing the moves in *reverse* order,
8829 // though, we can efficiently *shuffle* it! For this reason, we will be
8830 // replacing instructions starting from the *end* of the run. Since the
8831 // solution is optimal, we don't need to worry about running out of space:
8832 1931 int current = len - 1;
8833
2/2
✓ Branch 0 taken 5793 times.
✓ Branch 1 taken 1931 times.
 7724 for (int i = 0; i < depth; i++) {
8834 // Skip items that have already been visited, or just happen to be in
8835 // the correct location:
8836
3/4
✓ Branch 0 taken 1931 times.
✓ Branch 1 taken 3862 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1931 times.
 5793 if (stack[i] == VISITED || stack[i] == i) {
8837 3862 continue;
8838 }
8839 // Okay, we've found an item that hasn't been visited. It forms a cycle
8840 // with other items; traversing the cycle and swapping each item with
8841 // the next will put them all in the correct place. The weird
8842 // loop-and-a-half is necessary to insert 0 into every cycle, since we
8843 // can only swap from that position:
8844 1931 int j = i;
8845 5793 while (true) {
8846 // Skip the actual swap if our item is zero, since swapping the top
8847 // item with itself is pointless:
8848
2/2
✓ Branch 0 taken 3862 times.
✓ Branch 1 taken 3862 times.
 7724 if (j) {
8849 assert(0 <= current);
8850 // SWAPs are 1-indexed:
8851 3862 instructions[current].i_opcode = SWAP;
8852 3862 instructions[current--].i_oparg = j + 1;
8853 }
8854
2/2
✓ Branch 0 taken 1931 times.
✓ Branch 1 taken 5793 times.
 7724 if (stack[j] == VISITED) {
8855 // Completed the cycle:
8856 assert(j == i);
8857 1931 break;
8858 }
8859 5793 int next_j = stack[j];
8860 5793 stack[j] = VISITED;
8861 5793 j = next_j;
8862 }
8863 }
8864 // NOP out any unused instructions:
8865
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1931 times.
 1931 while (0 <= current) {
8866 ✗ instructions[current--].i_opcode = NOP;
8867 }
8868 1931 PyMem_Free(stack);
8869 1931 *ix += len - 1;
8870 1931 return 0;
8871 }
8872
8873 // This list is pretty small, since it's only okay to reorder opcodes that:
8874 // - can't affect control flow (like jumping or raising exceptions)
8875 // - can't invoke arbitrary code (besides finalizers)
8876 // - only touch the TOS (and pop it when finished)
8877 #define SWAPPABLE(opcode) \
8878 ((opcode) == STORE_FAST || (opcode) == POP_TOP)
8879
8880 static int
8881 17732 next_swappable_instruction(basicblock *block, int i, int lineno)
8882 {
8883
2/2
✓ Branch 0 taken 17660 times.
✓ Branch 1 taken 72 times.
 17732 while (++i < block->b_iused) {
8884 17660 struct instr *instruction = &block->b_instr[i];
8885
4/4
✓ Branch 0 taken 4492 times.
✓ Branch 1 taken 13168 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 4476 times.
 17660 if (0 <= lineno && instruction->i_loc.lineno != lineno) {
8886 // Optimizing across this instruction could cause user-visible
8887 // changes in the names bound between line tracing events!
8888 16 return -1;
8889 }
8890
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17644 times.
 17644 if (instruction->i_opcode == NOP) {
8891 ✗ continue;
8892 }
8893
4/4
✓ Branch 0 taken 12091 times.
✓ Branch 1 taken 5553 times.
✓ Branch 2 taken 1568 times.
✓ Branch 3 taken 10523 times.
 17644 if (SWAPPABLE(instruction->i_opcode)) {
8894 7121 return i;
8895 }
8896 10523 return -1;
8897 }
8898 72 return -1;
8899 }
8900
8901 // Attempt to apply SWAPs statically by swapping *instructions* rather than
8902 // stack items. For example, we can replace SWAP(2), POP_TOP, STORE_FAST(42)
8903 // with the more efficient NOP, STORE_FAST(42), POP_TOP.
8904 static void
8905 13163 apply_static_swaps(basicblock *block, int i)
8906 {
8907 // SWAPs are to our left, and potential swaperands are to our right:
8908
2/2
✓ Branch 0 taken 18264 times.
✓ Branch 1 taken 3 times.
 18267 for (; 0 <= i; i--) {
8909 assert(i < block->b_iused);
8910 18264 struct instr *swap = &block->b_instr[i];
8911
2/2
✓ Branch 0 taken 5101 times.
✓ Branch 1 taken 13163 times.
 18264 if (swap->i_opcode != SWAP) {
8912
4/6
✓ Branch 0 taken 2549 times.
✓ Branch 1 taken 2552 times.
✓ Branch 2 taken 2549 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2549 times.
 5101 if (swap->i_opcode == NOP || SWAPPABLE(swap->i_opcode)) {
8913 // Nope, but we know how to handle these. Keep looking:
8914 2552 continue;
8915 }
8916 // We can't reason about what this instruction does. Bail:
8917 13160 return;
8918 }
8919 13163 int j = next_swappable_instruction(block, i, -1);
8920
2/2
✓ Branch 0 taken 8976 times.
✓ Branch 1 taken 4187 times.
 13163 if (j < 0) {
8921 8976 return;
8922 }
8923 4187 int k = j;
8924 4187 int lineno = block->b_instr[j].i_loc.lineno;
8925
2/2
✓ Branch 0 taken 4569 times.
✓ Branch 1 taken 2552 times.
 7121 for (int count = swap->i_oparg - 1; 0 < count; count--) {
8926 4569 k = next_swappable_instruction(block, k, lineno);
8927
2/2
✓ Branch 0 taken 1635 times.
✓ Branch 1 taken 2934 times.
 4569 if (k < 0) {
8928 1635 return;
8929 }
8930 }
8931 // Success!
8932 2552 swap->i_opcode = NOP;
8933 2552 struct instr temp = block->b_instr[j];
8934 2552 block->b_instr[j] = block->b_instr[k];
8935 2552 block->b_instr[k] = temp;
8936 }
8937 }
8938
8939 // Attempt to eliminate jumps to jumps by updating inst to jump to
8940 // target->i_target using the provided opcode. Return whether or not the
8941 // optimization was successful.
8942 static bool
8943 26008 jump_thread(struct instr *inst, struct instr *target, int opcode)
8944 {
8945 assert(!IS_VIRTUAL_OPCODE(opcode) || IS_VIRTUAL_JUMP_OPCODE(opcode));
8946 assert(is_jump(inst));
8947 assert(is_jump(target));
8948 // bpo-45773: If inst->i_target == target->i_target, then nothing actually
8949 // changes (and we fall into an infinite loop):
8950
4/4
✓ Branch 0 taken 14057 times.
✓ Branch 1 taken 11951 times.
✓ Branch 2 taken 14045 times.
✓ Branch 3 taken 12 times.
 26008 if ((inst->i_loc.lineno == target->i_loc.lineno || target->i_loc.lineno == -1) &&
8951
1/2
✓ Branch 0 taken 25996 times.
✗ Branch 1 not taken.
 25996 inst->i_target != target->i_target)
8952 {
8953 25996 inst->i_target = target->i_target;
8954 25996 inst->i_opcode = opcode;
8955 25996 return true;
8956 }
8957 12 return false;
8958 }
8959
8960 /* Maximum size of basic block that should be copied in optimizer */
8961 #define MAX_COPY_SIZE 4
8962
8963 /* Optimization */
8964 static int
8965 1366225 optimize_basic_block(PyObject *const_cache, basicblock *bb, PyObject *consts)
8966 {
8967 assert(PyDict_CheckExact(const_cache));
8968 assert(PyList_CheckExact(consts));
8969 struct instr nop;
8970 1366225 nop.i_opcode = NOP;
8971 struct instr *target;
8972
2/2
✓ Branch 0 taken 15816526 times.
✓ Branch 1 taken 1366225 times.
 17182751 for (int i = 0; i < bb->b_iused; i++) {
8973 15816526 struct instr *inst = &bb->b_instr[i];
8974 15816526 int oparg = inst->i_oparg;
8975
2/2
✓ Branch 0 taken 14496511 times.
✓ Branch 1 taken 1320015 times.
 15816526 int nextop = i+1 < bb->b_iused ? bb->b_instr[i+1].i_opcode : 0;
8976
4/4
✓ Branch 1 taken 15339105 times.
✓ Branch 2 taken 477421 times.
✓ Branch 4 taken 37487 times.
✓ Branch 5 taken 15301618 times.
 15816526 if (is_jump(inst) || is_block_push(inst)) {
8977 /* Skip over empty basic blocks. */
8978
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 514908 times.
 514908 while (inst->i_target->b_iused == 0) {
8979 ✗ inst->i_target = inst->i_target->b_next;
8980 }
8981 514908 target = &inst->i_target->b_instr[0];
8982 514908 assert(!IS_ASSEMBLER_OPCODE(target->i_opcode));
8983 }
8984 else {
8985 15301618 target = &nop;
8986 }
8987 assert(!IS_ASSEMBLER_OPCODE(inst->i_opcode));
8988
13/13
✓ Branch 0 taken 2251622 times.
✓ Branch 1 taken 222138 times.
✓ Branch 2 taken 8966 times.
✓ Branch 3 taken 4811 times.
✓ Branch 4 taken 21224 times.
✓ Branch 5 taken 157245 times.
✓ Branch 6 taken 107945 times.
✓ Branch 7 taken 123506 times.
✓ Branch 8 taken 50394 times.
✓ Branch 9 taken 13163 times.
✓ Branch 10 taken 53723 times.
✓ Branch 11 taken 1134912 times.
✓ Branch 12 taken 11666877 times.
 15816526 switch (inst->i_opcode) {
8989 /* Remove LOAD_CONST const; conditional jump */
8990
4/4
✓ Branch 0 taken 2188 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 26200 times.
✓ Branch 3 taken 2223230 times.
 2251622 case LOAD_CONST:
8991 {
8992 PyObject* cnt;
8993 int is_true;
8994 int jump_if_true;
8995 switch(nextop) {
8996 2188 case POP_JUMP_IF_FALSE:
8997 case POP_JUMP_IF_TRUE:
8998 2188 cnt = get_const_value(inst->i_opcode, oparg, consts);
8999
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2188 times.
 2188 if (cnt == NULL) {
9000 ✗ goto error;
9001 }
9002 2188 is_true = PyObject_IsTrue(cnt);
9003 2188 Py_DECREF(cnt);
9004
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2188 times.
 2188 if (is_true == -1) {
9005 ✗ goto error;
9006 }
9007 2188 inst->i_opcode = NOP;
9008 2188 jump_if_true = nextop == POP_JUMP_IF_TRUE;
9009
2/2
✓ Branch 0 taken 1048 times.
✓ Branch 1 taken 1140 times.
 2188 if (is_true == jump_if_true) {
9010 1048 bb->b_instr[i+1].i_opcode = JUMP;
9011 }
9012 else {
9013 1140 bb->b_instr[i+1].i_opcode = NOP;
9014 }
9015 2188 break;
9016 4 case JUMP_IF_FALSE_OR_POP:
9017 case JUMP_IF_TRUE_OR_POP:
9018 4 cnt = get_const_value(inst->i_opcode, oparg, consts);
9019
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (cnt == NULL) {
9020 ✗ goto error;
9021 }
9022 4 is_true = PyObject_IsTrue(cnt);
9023 4 Py_DECREF(cnt);
9024
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (is_true == -1) {
9025 ✗ goto error;
9026 }
9027 4 jump_if_true = nextop == JUMP_IF_TRUE_OR_POP;
9028
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (is_true == jump_if_true) {
9029 ✗ bb->b_instr[i+1].i_opcode = JUMP;
9030 }
9031 else {
9032 4 inst->i_opcode = NOP;
9033 4 bb->b_instr[i+1].i_opcode = NOP;
9034 }
9035 4 break;
9036 26200 case IS_OP:
9037 26200 cnt = get_const_value(inst->i_opcode, oparg, consts);
9038
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26200 times.
 26200 if (cnt == NULL) {
9039 ✗ goto error;
9040 }
9041
2/2
✓ Branch 0 taken 26091 times.
✓ Branch 1 taken 109 times.
 26200 int jump_op = i+2 < bb->b_iused ? bb->b_instr[i+2].i_opcode : 0;
9042
6/6
✓ Branch 0 taken 20990 times.
✓ Branch 1 taken 5210 times.
✓ Branch 2 taken 3733 times.
✓ Branch 3 taken 17257 times.
✓ Branch 4 taken 2963 times.
✓ Branch 5 taken 770 times.
 26200 if (Py_IsNone(cnt) && (jump_op == POP_JUMP_IF_FALSE || jump_op == POP_JUMP_IF_TRUE)) {
9043 20220 unsigned char nextarg = bb->b_instr[i+1].i_oparg;
9044 20220 inst->i_opcode = NOP;
9045 20220 bb->b_instr[i+1].i_opcode = NOP;
9046 20220 bb->b_instr[i+2].i_opcode = nextarg ^ (jump_op == POP_JUMP_IF_FALSE) ?
9047
2/2
✓ Branch 0 taken 8595 times.
✓ Branch 1 taken 11625 times.
 20220 POP_JUMP_IF_NOT_NONE : POP_JUMP_IF_NONE;
9048 }
9049 26200 Py_DECREF(cnt);
9050 26200 break;
9051 }
9052 2251622 break;
9053 }
9054
9055 /* Try to fold tuples of constants.
9056 Skip over BUILD_TUPLE(1) UNPACK_SEQUENCE(1).
9057 Replace BUILD_TUPLE(2) UNPACK_SEQUENCE(2) with SWAP(2).
9058 Replace BUILD_TUPLE(3) UNPACK_SEQUENCE(3) with SWAP(3). */
9059 222138 case BUILD_TUPLE:
9060
3/4
✓ Branch 0 taken 3242 times.
✓ Branch 1 taken 218896 times.
✓ Branch 2 taken 3242 times.
✗ Branch 3 not taken.
 222138 if (nextop == UNPACK_SEQUENCE && oparg == bb->b_instr[i+1].i_oparg) {
9061 3141 switch(oparg) {
9062 ✗ case 1:
9063 ✗ inst->i_opcode = NOP;
9064 ✗ bb->b_instr[i+1].i_opcode = NOP;
9065 ✗ continue;
9066 3141 case 2:
9067 case 3:
9068 3141 inst->i_opcode = NOP;
9069 3141 bb->b_instr[i+1].i_opcode = SWAP;
9070 3141 continue;
9071 }
9072 }
9073
2/2
✓ Branch 0 taken 218588 times.
✓ Branch 1 taken 409 times.
 218997 if (i >= oparg) {
9074
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 218588 times.
 218588 if (fold_tuple_on_constants(const_cache, inst-oparg, oparg, consts)) {
9075 ✗ goto error;
9076 }
9077 }
9078 218997 break;
9079
9080 /* Simplify conditional jump to conditional jump where the
9081 result of the first test implies the success of a similar
9082 test or the failure of the opposite test.
9083 Arises in code like:
9084 "a and b or c"
9085 "(a and b) and c"
9086 "(a or b) or c"
9087 "(a or b) and c"
9088 x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_FALSE_OR_POP z
9089 --> x:JUMP_IF_FALSE_OR_POP z
9090 x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_TRUE_OR_POP z
9091 --> x:POP_JUMP_IF_FALSE y+1
9092 where y+1 is the instruction following the second test.
9093 */
9094 8966 case JUMP_IF_FALSE_OR_POP:
9095
3/4
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 326 times.
✓ Branch 3 taken 8630 times.
 8966 switch (target->i_opcode) {
9096 ✗ case POP_JUMP_IF_FALSE:
9097 ✗ i -= jump_thread(inst, target, POP_JUMP_IF_FALSE);
9098 ✗ break;
9099 10 case JUMP:
9100 case JUMP_IF_FALSE_OR_POP:
9101 10 i -= jump_thread(inst, target, JUMP_IF_FALSE_OR_POP);
9102 10 break;
9103 326 case JUMP_IF_TRUE_OR_POP:
9104 case POP_JUMP_IF_TRUE:
9105
2/2
✓ Branch 0 taken 309 times.
✓ Branch 1 taken 17 times.
 326 if (inst->i_loc.lineno == target->i_loc.lineno) {
9106 // We don't need to bother checking for loops here,
9107 // since a block's b_next cannot point to itself:
9108 assert(inst->i_target != inst->i_target->b_next);
9109 309 inst->i_opcode = POP_JUMP_IF_FALSE;
9110 309 inst->i_target = inst->i_target->b_next;
9111 309 --i;
9112 }
9113 326 break;
9114 }
9115 8966 break;
9116 4811 case JUMP_IF_TRUE_OR_POP:
9117
3/4
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 39 times.
✓ Branch 3 taken 4757 times.
 4811 switch (target->i_opcode) {
9118 ✗ case POP_JUMP_IF_TRUE:
9119 ✗ i -= jump_thread(inst, target, POP_JUMP_IF_TRUE);
9120 ✗ break;
9121 15 case JUMP:
9122 case JUMP_IF_TRUE_OR_POP:
9123 15 i -= jump_thread(inst, target, JUMP_IF_TRUE_OR_POP);
9124 15 break;
9125 39 case JUMP_IF_FALSE_OR_POP:
9126 case POP_JUMP_IF_FALSE:
9127
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 21 times.
 39 if (inst->i_loc.lineno == target->i_loc.lineno) {
9128 // We don't need to bother checking for loops here,
9129 // since a block's b_next cannot point to itself:
9130 assert(inst->i_target != inst->i_target->b_next);
9131 18 inst->i_opcode = POP_JUMP_IF_TRUE;
9132 18 inst->i_target = inst->i_target->b_next;
9133 18 --i;
9134 }
9135 39 break;
9136 }
9137 4811 break;
9138 21224 case POP_JUMP_IF_NOT_NONE:
9139 case POP_JUMP_IF_NONE:
9140
2/2
✓ Branch 0 taken 1004 times.
✓ Branch 1 taken 20220 times.
 21224 switch (target->i_opcode) {
9141 1004 case JUMP:
9142 1004 i -= jump_thread(inst, target, inst->i_opcode);
9143 }
9144 21224 break;
9145 157245 case POP_JUMP_IF_FALSE:
9146
2/2
✓ Branch 0 taken 12236 times.
✓ Branch 1 taken 145009 times.
 157245 switch (target->i_opcode) {
9147 12236 case JUMP:
9148 12236 i -= jump_thread(inst, target, POP_JUMP_IF_FALSE);
9149 }
9150 157245 break;
9151 107945 case POP_JUMP_IF_TRUE:
9152
2/2
✓ Branch 0 taken 2917 times.
✓ Branch 1 taken 105028 times.
 107945 switch (target->i_opcode) {
9153 2917 case JUMP:
9154 2917 i -= jump_thread(inst, target, POP_JUMP_IF_TRUE);
9155 }
9156 107945 break;
9157 123506 case JUMP:
9158
2/2
✓ Branch 0 taken 9826 times.
✓ Branch 1 taken 113680 times.
 123506 switch (target->i_opcode) {
9159 9826 case JUMP:
9160 9826 i -= jump_thread(inst, target, JUMP);
9161 }
9162 123506 break;
9163 50394 case FOR_ITER:
9164 50394 if (target->i_opcode == JUMP) {
9165 /* This will not work now because the jump (at target) could
9166 * be forward or backward and FOR_ITER only jumps forward. We
9167 * can re-enable this if ever we implement a backward version
9168 * of FOR_ITER.
9169 */
9170 /*
9171 i -= jump_thread(inst, target, FOR_ITER);
9172 */
9173 }
9174 50394 break;
9175 13163 case SWAP:
9176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13163 times.
 13163 if (oparg == 1) {
9177 ✗ inst->i_opcode = NOP;
9178 ✗ break;
9179 }
9180
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13163 times.
 13163 if (swaptimize(bb, &i)) {
9181 ✗ goto error;
9182 }
9183 13163 apply_static_swaps(bb, i);
9184 13163 break;
9185 53723 case KW_NAMES:
9186 53723 break;
9187 1134912 case PUSH_NULL:
9188
3/4
✓ Branch 0 taken 1024429 times.
✓ Branch 1 taken 110483 times.
✓ Branch 2 taken 1024429 times.
✗ Branch 3 not taken.
 1134912 if (nextop == LOAD_GLOBAL && (inst[1].i_opcode & 1) == 0) {
9189 1024429 inst->i_opcode = NOP;
9190 1024429 inst->i_oparg = 0;
9191 1024429 inst[1].i_oparg |= 1;
9192 }
9193 1134912 break;
9194 15816526 default:
9195 /* All HAS_CONST opcodes should be handled with LOAD_CONST */
9196 assert (!HAS_CONST(inst->i_opcode));
9197 }
9198 }
9199 1366225 return 0;
9200 ✗ error:
9201 ✗ return -1;
9202 }
9203
9204 /* If this block ends with an unconditional jump to an exit block,
9205 * then remove the jump and extend this block with the target.
9206 */
9207 static int
9208 2732450 extend_block(basicblock *bb) {
9209
2/2
✓ Branch 0 taken 145154 times.
✓ Branch 1 taken 2587296 times.
 2732450 if (bb->b_iused == 0) {
9210 145154 return 0;
9211 }
9212 2587296 struct instr *last = &bb->b_instr[bb->b_iused-1];
9213
2/2
✓ Branch 0 taken 2332711 times.
✓ Branch 1 taken 254585 times.
 2587296 if (last->i_opcode != JUMP &&
9214
1/2
✓ Branch 0 taken 2332711 times.
✗ Branch 1 not taken.
 2332711 last->i_opcode != JUMP_FORWARD &&
9215
1/2
✓ Branch 0 taken 2332711 times.
✗ Branch 1 not taken.
 2332711 last->i_opcode != JUMP_BACKWARD) {
9216 2332711 return 0;
9217 }
9218
4/4
✓ Branch 1 taken 52255 times.
✓ Branch 2 taken 202330 times.
✓ Branch 3 taken 30597 times.
✓ Branch 4 taken 21658 times.
 254585 if (basicblock_exits_scope(last->i_target) && last->i_target->b_iused <= MAX_COPY_SIZE) {
9219 30597 basicblock *to_copy = last->i_target;
9220 30597 last->i_opcode = NOP;
9221
2/2
✓ Branch 0 taken 66957 times.
✓ Branch 1 taken 30597 times.
 97554 for (int i = 0; i < to_copy->b_iused; i++) {
9222 66957 int index = basicblock_next_instr(bb);
9223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 66957 times.
 66957 if (index < 0) {
9224 ✗ return -1;
9225 }
9226 66957 bb->b_instr[index] = to_copy->b_instr[i];
9227 }
9228 }
9229 254585 return 0;
9230 }
9231
9232 static void
9233 3891718 clean_basic_block(basicblock *bb) {
9234 /* Remove NOPs when legal to do so. */
9235 3891718 int dest = 0;
9236 3891718 int prev_lineno = -1;
9237
2/2
✓ Branch 0 taken 44883453 times.
✓ Branch 1 taken 3891718 times.
 48775171 for (int src = 0; src < bb->b_iused; src++) {
9238 44883453 int lineno = bb->b_instr[src].i_loc.lineno;
9239
2/2
✓ Branch 0 taken 1271777 times.
✓ Branch 1 taken 43611676 times.
 44883453 if (bb->b_instr[src].i_opcode == NOP) {
9240 /* Eliminate no-op if it doesn't have a line number */
9241
2/2
✓ Branch 0 taken 42319 times.
✓ Branch 1 taken 1229458 times.
 1271777 if (lineno < 0) {
9242 42319 continue;
9243 }
9244 /* or, if the previous instruction had the same line number. */
9245
2/2
✓ Branch 0 taken 784494 times.
✓ Branch 1 taken 444964 times.
 1229458 if (prev_lineno == lineno) {
9246 784494 continue;
9247 }
9248 /* or, if the next instruction has same line number or no line number */
9249
2/2
✓ Branch 0 taken 427731 times.
✓ Branch 1 taken 17233 times.
 444964 if (src < bb->b_iused - 1) {
9250 427731 int next_lineno = bb->b_instr[src+1].i_loc.lineno;
9251
4/4
✓ Branch 0 taken 422278 times.
✓ Branch 1 taken 5453 times.
✓ Branch 2 taken 399536 times.
✓ Branch 3 taken 22742 times.
 427731 if (next_lineno < 0 || next_lineno == lineno) {
9252 404989 bb->b_instr[src+1].i_loc = bb->b_instr[src].i_loc;
9253 404989 continue;
9254 }
9255 }
9256 else {
9257 17233 basicblock* next = bb->b_next;
9258
3/4
✓ Branch 0 taken 17371 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 138 times.
✓ Branch 3 taken 17233 times.
 17371 while (next && next->b_iused == 0) {
9259 138 next = next->b_next;
9260 }
9261 /* or if last instruction in BB and next BB has same line number */
9262
1/2
✓ Branch 0 taken 17233 times.
✗ Branch 1 not taken.
 17233 if (next) {
9263
2/2
✓ Branch 0 taken 305 times.
✓ Branch 1 taken 16928 times.
 17233 if (lineno == next->b_instr[0].i_loc.lineno) {
9264 305 continue;
9265 }
9266 }
9267 }
9268
9269 }
9270
2/2
✓ Branch 0 taken 7954085 times.
✓ Branch 1 taken 35697261 times.
 43651346 if (dest != src) {
9271 7954085 bb->b_instr[dest] = bb->b_instr[src];
9272 }
9273 43651346 dest++;
9274 43651346 prev_lineno = lineno;
9275 }
9276 assert(dest <= bb->b_iused);
9277 3891718 bb->b_iused = dest;
9278 3891718 }
9279
9280 static int
9281 1366225 normalize_basic_block(basicblock *bb) {
9282 /* Mark blocks as exit and/or nofallthrough.
9283 Raise SystemError if CFG is malformed. */
9284
2/2
✓ Branch 0 taken 15673699 times.
✓ Branch 1 taken 1366225 times.
 17039924 for (int i = 0; i < bb->b_iused; i++) {
9285 15673699 int opcode = bb->b_instr[i].i_opcode;
9286 assert(!IS_ASSEMBLER_OPCODE(opcode));
9287
12/14
✓ Branch 0 taken 15532803 times.
✓ Branch 1 taken 140896 times.
✓ Branch 2 taken 15531138 times.
✓ Branch 3 taken 1665 times.
✓ Branch 4 taken 15531138 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 15531138 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 15368126 times.
✓ Branch 9 taken 163012 times.
✓ Branch 10 taken 15259020 times.
✓ Branch 11 taken 109106 times.
✓ Branch 13 taken 65818 times.
✓ Branch 14 taken 15193202 times.
 15673699 int is_jump = IS_JUMP_OPCODE(opcode);
9288
6/6
✓ Branch 0 taken 15173385 times.
✓ Branch 1 taken 500314 times.
✓ Branch 2 taken 15074616 times.
✓ Branch 3 taken 98769 times.
✓ Branch 4 taken 37484 times.
✓ Branch 5 taken 15037132 times.
 15673699 int is_exit = IS_SCOPE_EXIT_OPCODE(opcode);
9289
4/4
✓ Branch 0 taken 15037132 times.
✓ Branch 1 taken 636567 times.
✓ Branch 2 taken 480497 times.
✓ Branch 3 taken 14556635 times.
 15673699 if (is_exit || is_jump) {
9290
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1117064 times.
 1117064 if (i != bb->b_iused-1) {
9291 ✗ PyErr_SetString(PyExc_SystemError, "malformed control flow graph.");
9292 ✗ return -1;
9293 }
9294 }
9295
2/2
✓ Branch 0 taken 480497 times.
✓ Branch 1 taken 15193202 times.
 15673699 if (is_jump) {
9296 /* Skip over empty basic blocks. */
9297
2/2
✓ Branch 0 taken 96239 times.
✓ Branch 1 taken 480497 times.
 576736 while (bb->b_instr[i].i_target->b_iused == 0) {
9298 96239 bb->b_instr[i].i_target = bb->b_instr[i].i_target->b_next;
9299 }
9300 }
9301 }
9302 1366225 return 0;
9303 }
9304
9305 static int
9306 448800 mark_reachable(basicblock *entryblock) {
9307 448800 basicblock **stack = make_cfg_traversal_stack(entryblock);
9308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 448800 times.
 448800 if (stack == NULL) {
9309 ✗ return -1;
9310 }
9311 448800 basicblock **sp = stack;
9312 448800 entryblock->b_predecessors = 1;
9313 448800 *sp++ = entryblock;
9314
2/2
✓ Branch 0 taken 1263473 times.
✓ Branch 1 taken 448800 times.
 1712273 while (sp > stack) {
9315 1263473 basicblock *b = *(--sp);
9316 1263473 b->b_visited = 1;
9317
4/4
✓ Branch 0 taken 829236 times.
✓ Branch 1 taken 434237 times.
✓ Branch 3 taken 528542 times.
✓ Branch 4 taken 300694 times.
 1263473 if (b->b_next && BB_HAS_FALLTHROUGH(b)) {
9318
2/2
✓ Branch 0 taken 471838 times.
✓ Branch 1 taken 56704 times.
 528542 if (!b->b_next->b_visited) {
9319 assert(b->b_next->b_predecessors == 0);
9320 471838 *sp++ = b->b_next;
9321 }
9322 528542 b->b_next->b_predecessors++;
9323 }
9324
2/2
✓ Branch 0 taken 14528576 times.
✓ Branch 1 taken 1263473 times.
 15792049 for (int i = 0; i < b->b_iused; i++) {
9325 basicblock *target;
9326 14528576 struct instr *instr = &b->b_instr[i];
9327
4/4
✓ Branch 1 taken 14095545 times.
✓ Branch 2 taken 433031 times.
✓ Branch 4 taken 37475 times.
✓ Branch 5 taken 14058070 times.
 14528576 if (is_jump(instr) || is_block_push(instr)) {
9328 470506 target = instr->i_target;
9329
2/2
✓ Branch 0 taken 342835 times.
✓ Branch 1 taken 127671 times.
 470506 if (!target->b_visited) {
9330 assert(target->b_predecessors == 0 || target == b->b_next);
9331 342835 *sp++ = target;
9332 }
9333 470506 target->b_predecessors++;
9334
2/2
✓ Branch 1 taken 37475 times.
✓ Branch 2 taken 433031 times.
 470506 if (is_block_push(instr)) {
9335 37475 target->b_except_predecessors++;
9336 }
9337 assert(target->b_except_predecessors == 0 ||
9338 target->b_except_predecessors == target->b_predecessors);
9339 }
9340 }
9341 }
9342 448800 PyMem_Free(stack);
9343 448800 return 0;
9344 }
9345
9346 static void
9347 455854 eliminate_empty_basic_blocks(basicblock *entryblock) {
9348 /* Eliminate empty blocks */
9349
2/2
✓ Branch 0 taken 1420067 times.
✓ Branch 1 taken 455854 times.
 1875921 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9350 1420067 basicblock *next = b->b_next;
9351
2/2
✓ Branch 0 taken 964213 times.
✓ Branch 1 taken 455854 times.
 1420067 if (next) {
9352
4/4
✓ Branch 0 taken 118101 times.
✓ Branch 1 taken 949650 times.
✓ Branch 2 taken 103538 times.
✓ Branch 3 taken 14563 times.
 1067751 while (next->b_iused == 0 && next->b_next) {
9353 103538 next = next->b_next;
9354 }
9355 964213 b->b_next = next;
9356 }
9357 }
9358
2/2
✓ Branch 0 taken 1420067 times.
✓ Branch 1 taken 455854 times.
 1875921 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9359
2/2
✓ Branch 0 taken 14563 times.
✓ Branch 1 taken 1405504 times.
 1420067 if (b->b_iused == 0) {
9360 14563 continue;
9361 }
9362
2/2
✓ Branch 0 taken 15624254 times.
✓ Branch 1 taken 1405504 times.
 17029758 for (int i = 0; i < b->b_iused; i++) {
9363 15624254 struct instr *instr = &b->b_instr[i];
9364
4/4
✓ Branch 1 taken 15125365 times.
✓ Branch 2 taken 498889 times.
✓ Branch 4 taken 37475 times.
✓ Branch 5 taken 15087890 times.
 15624254 if (is_jump(instr) || is_block_push(instr)) {
9365 536364 basicblock *target = instr->i_target;
9366
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 536364 times.
 536427 while (target->b_iused == 0) {
9367 63 target = target->b_next;
9368 }
9369 536364 instr->i_target = target;
9370 }
9371 }
9372 }
9373 455854 }
9374
9375
9376 /* If an instruction has no line number, but it's predecessor in the BB does,
9377 * then copy the line number. If a successor block has no line number, and only
9378 * one predecessor, then inherit the line number.
9379 * This ensures that all exit blocks (with one predecessor) receive a line number.
9380 * Also reduces the size of the line number table,
9381 * but has no impact on the generated line number events.
9382 */
9383 static void
9384 448800 propagate_line_numbers(basicblock *entryblock) {
9385
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9386
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1262784 times.
 1262784 if (b->b_iused == 0) {
9387 ✗ continue;
9388 }
9389
9390 1262784 struct location prev_location = NO_LOCATION;
9391
2/2
✓ Branch 0 taken 14562721 times.
✓ Branch 1 taken 1262784 times.
 15825505 for (int i = 0; i < b->b_iused; i++) {
9392
2/2
✓ Branch 0 taken 923932 times.
✓ Branch 1 taken 13638789 times.
 14562721 if (b->b_instr[i].i_loc.lineno < 0) {
9393 923932 b->b_instr[i].i_loc = prev_location;
9394 }
9395 else {
9396 13638789 prev_location = b->b_instr[i].i_loc;
9397 }
9398 }
9399
4/4
✓ Branch 1 taken 513193 times.
✓ Branch 2 taken 749591 times.
✓ Branch 3 taken 398169 times.
✓ Branch 4 taken 115024 times.
 1262784 if (BB_HAS_FALLTHROUGH(b) && b->b_next->b_predecessors == 1) {
9400 assert(b->b_next->b_iused);
9401
2/2
✓ Branch 0 taken 20049 times.
✓ Branch 1 taken 378120 times.
 398169 if (b->b_next->b_instr[0].i_loc.lineno < 0) {
9402 20049 b->b_next->b_instr[0].i_loc = prev_location;
9403 }
9404 }
9405
2/2
✓ Branch 1 taken 433031 times.
✓ Branch 2 taken 829753 times.
 1262784 if (is_jump(&b->b_instr[b->b_iused-1])) {
9406 433031 basicblock *target = b->b_instr[b->b_iused-1].i_target;
9407
2/2
✓ Branch 0 taken 244657 times.
✓ Branch 1 taken 188374 times.
 433031 if (target->b_predecessors == 1) {
9408
2/2
✓ Branch 0 taken 45697 times.
✓ Branch 1 taken 198960 times.
 244657 if (target->b_instr[0].i_loc.lineno < 0) {
9409 45697 target->b_instr[0].i_loc = prev_location;
9410 }
9411 }
9412 }
9413 }
9414 448800 }
9415
9416 /* Perform optimizations on a control flow graph.
9417 The consts object should still be in list form to allow new constants
9418 to be appended.
9419
9420 All transformations keep the code size the same or smaller.
9421 For those that reduce size, the gaps are initially filled with
9422 NOPs. Later those NOPs are removed.
9423 */
9424
9425 static int
9426 448800 optimize_cfg(basicblock *entryblock, PyObject *consts, PyObject *const_cache)
9427 {
9428 assert(PyDict_CheckExact(const_cache));
9429
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9430
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1366225 times.
 1366225 if (optimize_basic_block(const_cache, b, consts)) {
9431 ✗ return -1;
9432 }
9433 1366225 clean_basic_block(b);
9434 assert(b->b_predecessors == 0);
9435 }
9436
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9437
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1366225 times.
 1366225 if (extend_block(b)) {
9438 ✗ return -1;
9439 }
9440 }
9441
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 448800 times.
 448800 if (mark_reachable(entryblock)) {
9442 ✗ return -1;
9443 }
9444 /* Delete unreachable instructions */
9445
2/2
✓ Branch 0 taken 1366225 times.
✓ Branch 1 taken 448800 times.
 1815025 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9446
2/2
✓ Branch 0 taken 102752 times.
✓ Branch 1 taken 1263473 times.
 1366225 if (b->b_predecessors == 0) {
9447 102752 b->b_iused = 0;
9448 }
9449 }
9450 448800 eliminate_empty_basic_blocks(entryblock);
9451
2/2
✓ Branch 0 taken 1262687 times.
✓ Branch 1 taken 448800 times.
 1711487 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9452 1262687 clean_basic_block(b);
9453 }
9454 448800 return 0;
9455 }
9456
9457 // Remove trailing unused constants.
9458 static int
9459 448800 trim_unused_consts(basicblock *entryblock, PyObject *consts)
9460 {
9461 assert(PyList_CheckExact(consts));
9462
9463 // The first constant may be docstring; keep it always.
9464 448800 int max_const_index = 0;
9465
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9466
2/2
✓ Branch 0 taken 14562721 times.
✓ Branch 1 taken 1262784 times.
 15825505 for (int i = 0; i < b->b_iused; i++) {
9467
2/2
✓ Branch 0 taken 12369464 times.
✓ Branch 1 taken 2193257 times.
 14562721 if ((b->b_instr[i].i_opcode == LOAD_CONST ||
9468
2/2
✓ Branch 0 taken 53716 times.
✓ Branch 1 taken 12315748 times.
 12369464 b->b_instr[i].i_opcode == KW_NAMES) &&
9469
2/2
✓ Branch 0 taken 861802 times.
✓ Branch 1 taken 1385171 times.
 2246973 b->b_instr[i].i_oparg > max_const_index) {
9470 861802 max_const_index = b->b_instr[i].i_oparg;
9471 }
9472 }
9473 }
9474
2/2
✓ Branch 1 taken 2645 times.
✓ Branch 2 taken 446155 times.
 448800 if (max_const_index+1 < PyList_GET_SIZE(consts)) {
9475 //fprintf(stderr, "removing trailing consts: max=%d, size=%d\n",
9476 // max_const_index, (int)PyList_GET_SIZE(consts));
9477
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 2645 times.
 2645 if (PyList_SetSlice(consts, max_const_index+1,
9478 PyList_GET_SIZE(consts), NULL) < 0) {
9479 ✗ return 1;
9480 }
9481 }
9482 448800 return 0;
9483 }
9484
9485 static inline int
9486 946224 is_exit_without_lineno(basicblock *b) {
9487
2/2
✓ Branch 1 taken 638272 times.
✓ Branch 2 taken 307952 times.
 946224 if (!basicblock_exits_scope(b)) {
9488 638272 return 0;
9489 }
9490
2/2
✓ Branch 0 taken 386275 times.
✓ Branch 1 taken 69187 times.
 455462 for (int i = 0; i < b->b_iused; i++) {
9491
2/2
✓ Branch 0 taken 238765 times.
✓ Branch 1 taken 147510 times.
 386275 if (b->b_instr[i].i_loc.lineno >= 0) {
9492 238765 return 0;
9493 }
9494 }
9495 69187 return 1;
9496 }
9497
9498 /* PEP 626 mandates that the f_lineno of a frame is correct
9499 * after a frame terminates. It would be prohibitively expensive
9500 * to continuously update the f_lineno field at runtime,
9501 * so we make sure that all exiting instruction (raises and returns)
9502 * have a valid line number, allowing us to compute f_lineno lazily.
9503 * We can do this by duplicating the exit blocks without line number
9504 * so that none have more than one predecessor. We can then safely
9505 * copy the line number from the sole predecessor block.
9506 */
9507 static int
9508 448800 duplicate_exits_without_lineno(basicblock *entryblock)
9509 {
9510 /* Copy all exit blocks without line number that are targets of a jump.
9511 */
9512
2/2
✓ Branch 0 taken 1277347 times.
✓ Branch 1 taken 448800 times.
 1726147 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9513
4/4
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 14563 times.
✓ Branch 3 taken 433031 times.
✓ Branch 4 taken 829753 times.
 1277347 if (b->b_iused > 0 && is_jump(&b->b_instr[b->b_iused-1])) {
9514 433031 basicblock *target = b->b_instr[b->b_iused-1].i_target;
9515
4/4
✓ Branch 1 taken 50819 times.
✓ Branch 2 taken 382212 times.
✓ Branch 3 taken 14660 times.
✓ Branch 4 taken 36159 times.
 433031 if (is_exit_without_lineno(target) && target->b_predecessors > 1) {
9516 14660 basicblock *new_target = copy_basicblock(target);
9517
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14660 times.
 14660 if (new_target == NULL) {
9518 ✗ return -1;
9519 }
9520 14660 new_target->b_instr[0].i_loc = b->b_instr[b->b_iused-1].i_loc;
9521 14660 b->b_instr[b->b_iused-1].i_target = new_target;
9522 14660 target->b_predecessors--;
9523 14660 new_target->b_predecessors = 1;
9524 14660 new_target->b_next = target->b_next;
9525 14660 target->b_next = new_target;
9526 }
9527 }
9528 }
9529 /* Eliminate empty blocks */
9530
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9531
4/4
✓ Branch 0 taken 828547 times.
✓ Branch 1 taken 448800 times.
✓ Branch 2 taken 14563 times.
✓ Branch 3 taken 813984 times.
 1277347 while (b->b_next && b->b_next->b_iused == 0) {
9532 14563 b->b_next = b->b_next->b_next;
9533 }
9534 }
9535 /* Any remaining reachable exit blocks without line number can only be reached by
9536 * fall through, and thus can only have a single predecessor */
9537
2/2
✓ Branch 0 taken 1262784 times.
✓ Branch 1 taken 448800 times.
 1711584 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
9538
4/6
✓ Branch 1 taken 513193 times.
✓ Branch 2 taken 749591 times.
✓ Branch 3 taken 513193 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 513193 times.
✗ Branch 6 not taken.
 1262784 if (BB_HAS_FALLTHROUGH(b) && b->b_next && b->b_iused > 0) {
9539
2/2
✓ Branch 1 taken 18368 times.
✓ Branch 2 taken 494825 times.
 513193 if (is_exit_without_lineno(b->b_next)) {
9540 assert(b->b_next->b_iused > 0);
9541 18368 b->b_next->b_instr[0].i_loc = b->b_instr[b->b_iused-1].i_loc;
9542 }
9543 }
9544 }
9545 448800 return 0;
9546 }
9547
9548
9549 /* Retained for API compatibility.
9550 * Optimization is now done in optimize_cfg */
9551
9552 PyObject *
9553 ✗ PyCode_Optimize(PyObject *code, PyObject* Py_UNUSED(consts),
9554 PyObject *Py_UNUSED(names), PyObject *Py_UNUSED(lnotab_obj))
9555 {
9556 ✗ Py_INCREF(code);
9557 ✗ return code;
9558 }
9559